Packages

Standard library

Third party

Other packages

Sub-repositories

Community

Other packages

Sub-repositories

These packages are part of the Go Project but outside the main Go tree. They are developed under looser compatibility requirements than the Go core. Install them with "go get".

• benchmarks — benchmarks to measure Go as it is developed.
• blog — blog.golang.org's implementation.
• build — build.golang.org's implementation.
• crypto — additional cryptography packages.
• debug — an experimental debugger for Go.
• image — additional imaging packages.
• mobile — experimental support for Go on mobile platforms.
• net — additional networking packages.
• perf — packages and tools for performance measurement, storage, and analysis.
• pkgsite — home of the pkg.go.dev website.
• review — a tool for working with Gerrit code reviews.
• sync — additional concurrency primitives.
• sys — packages for making system calls.
• text — packages for working with text.
• time — additional time packages.
• tools — godoc, goimports, gorename, and other tools.
• tour — tour.golang.org's implementation.
• exp — experimental and deprecated packages (handle with care; may change without warning).

Community

These services can help you find Open Source packages provided by the community.

• Pkg.go.dev - the Go package discovery site.
• Projects at the Go Wiki - a curated list of Go projects.

Source file src/goberkeley/berkeley/anode.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"errors"
     5  	"log"
     6  	"time"
     7  
     8  	zmq "github.com/pebbe/zmq4" // Librería para trabajar con ZeroMQ
     9  )
    10  
    11  // Interfaz Handler con el método HandleProcess
    12  type Handler interface {
    13  	HandleProcess(message string) (string, error)
    14  }
    15  
    16  // AbstractNode proporciona la funcionalidad base para nodos en el sistema.
    17  type AbstractNode struct {
    18  	Name          string
    19  	Address       string
    20  	Timeout       time.Duration
    21  	NodeAddresses map[string]string
    22  	Context       *zmq.Context
    23  	Socket        *zmq.Socket
    24  	Logger        *log.Logger
    25  	Handler       // Composición de la interfaz Handler
    26  }
    27  
    28  // NewAbstractNode crea e inicializa un nuevo nodo base.
    29  func NewAbstractNode(name, address string, timeout time.Duration) (*AbstractNode, error) {
    30  	context, err := zmq.NewContext()
    31  	if err != nil {
    32  		return nil, errors.New("error al crear el contexto ZeroMQ")
    33  	}
    34  
    35  	return &AbstractNode{
    36  		Name:    name,
    37  		Address: address,
    38  		Timeout: timeout,
    39  		Context: context,
    40  		Logger:  log.Default(),
    41  	}, nil
    42  }
    43  
    44  // InitializeNodeWithAddresses inicializa un nodo con direcciones de otros nodos.
    45  func InitializeNodeWithAddresses(name, address string, timeout time.Duration, addresses map[string]string) (*AbstractNode, error) {
    46  	var n *AbstractNode
    47  	n, err := NewAbstractNode(name, address, timeout)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	n.NodeAddresses = addresses
    52  	n.Logger.Printf("Nodo %s inicializado con direcciones %v", n.Name, addresses)
    53  	return n, nil
    54  }
    55  
    56  // SendMessageSync envía un mensaje de forma síncrona y espera una respuesta.
    57  func (n *AbstractNode) SendMessageSync(address string, message string) (string, error) {
    58  	// Creación del socket REQ (Request) para enviar el mensaje
    59  	var socket *zmq.Socket
    60  	socket, err := n.Context.NewSocket(zmq.REQ)
    61  	if err != nil {
    62  		n.Logger.Printf("Error al crear el socket REQ: %v", err) // Traza adicional
    63  		return "", errors.New("error al crear el socket REQ")
    64  	}
    65  	defer socket.Close()
    66  
    67  	// Establecer el timeout para recibir respuestas
    68  	socket.SetRcvtimeo(n.Timeout * time.Millisecond) // Convertir el timeout a milisegundos
    69  
    70  	// Traza: Mostrar el valor del timeout configurado
    71  	n.Logger.Printf("Timeout de recepción configurado a: %v milisegundos", int64(n.Timeout)) // Traza para el timeout
    72  
    73  	// Conectar al socket en la dirección proporcionada
    74  	err = socket.Connect("tcp://" + address)
    75  	if err != nil {
    76  		n.Logger.Printf("Error al conectar con %s: %v", address, err) // Traza adicional
    77  		return "", errors.New("error al conectar con " + address)
    78  	}
    79  
    80  	n.Logger.Printf("Conectado a %s", address) // Traza para verificar la conexión
    81  
    82  	// Enviar el mensaje al servidor
    83  	_, err = socket.Send(message, 0)
    84  	if err != nil {
    85  		n.Logger.Printf("Error al enviar el mensaje a %s: %v", address, err) // Traza adicional
    86  		return "", errors.New("error al enviar el mensaje")
    87  	}
    88  
    89  	n.Logger.Printf("Mensaje enviado a %s: %s", address, message) // Traza de envío
    90  
    91  	// Intentar recibir la respuesta
    92  	reply, err := socket.Recv(0)
    93  	if err != nil {
    94  		n.Logger.Printf("Error al recibir respuesta de %s: %v", address, err) // Traza para el error de recepción
    95  		return "", errors.New("no se recibió respuesta del socket")
    96  	}
    97  
    98  	n.Logger.Printf("Respuesta recibida de %s: %s", address, reply) // Traza de respuesta recibida
    99  	return reply, nil
   100  }
   101  
   102  // SendMessageAsync envía un mensaje de manera asíncrona.
   103  func (n *AbstractNode) SendMessageAsync(address, message string) error {
   104  	socket, err := n.Context.NewSocket(zmq.PUSH)
   105  	if err != nil {
   106  		return errors.New("error al crear el socket PUSH")
   107  	}
   108  	defer socket.Close()
   109  
   110  	err = socket.Connect("tcp://" + address)
   111  	if err != nil {
   112  		return errors.New("error al conectar con " + address)
   113  	}
   114  
   115  	_, err = socket.Send(message, 0)
   116  	if err != nil {
   117  		return errors.New("error al enviar el mensaje")
   118  	}
   119  
   120  	n.Logger.Printf("Mensaje asincrónico enviado a %s: %s", address, message)
   121  	return nil
   122  }
   123  
   124  // StartListening inicia el proceso de escucha para mensajes entrantes en el nodo.
   125  // Configura un socket de tipo REP (Response) para recibir y responder a mensajes.
   126  func (n *AbstractNode) StartListening() error {
   127  	// Log para indicar que estamos intentando crear un socket REP.
   128  	n.Logger.Printf("Intentando crear un socket REP para el nodo %s en la dirección %s", n.Name, n.Address)
   129  	socket, err := n.Context.NewSocket(zmq.REP)
   130  	if err != nil {
   131  		// Si ocurre un error al crear el socket, loguea el error y retorna un mensaje de error.
   132  		n.Logger.Printf("Error al crear el socket REP: %v", err)
   133  		return errors.New("error al crear el socket REP")
   134  	}
   135  	n.Socket = socket
   136  	n.Logger.Printf("Socket REP creado exitosamente para el nodo %s", n.Name)
   137  
   138  	// Enlaza el socket a la dirección TCP proporcionada en el nodo para esperar conexiones.
   139  	n.Logger.Printf("Enlazando el socket REP en la dirección tcp://%s", n.Address)
   140  	err = socket.Bind("tcp://" + n.Address)
   141  	if err != nil {
   142  		// Si ocurre un error al enlazar el socket, loguea el error y retorna un mensaje de error.
   143  		n.Logger.Printf("Error al enlazar el socket en %s: %v", n.Address, err)
   144  		return errors.New("error al enlazar el socket en " + n.Address)
   145  	}
   146  	n.Logger.Printf("Socket enlazado exitosamente en %s", n.Address)
   147  
   148  	// Inicia una nueva goroutine para escuchar de manera concurrente sin bloquear el hilo principal.
   149  	n.Logger.Printf("Iniciando goroutine para escuchar en el nodo %s", n.Name)
   150  	go func() {
   151  		// Logea que el nodo ha comenzado a escuchar en la dirección configurada.
   152  		n.Logger.Printf("Nodo %s escuchando en %s", n.Name, n.Address)
   153  
   154  		// Entra en un bucle infinito para recibir y procesar mensajes.
   155  		for {
   156  			// Recibe un mensaje del socket.
   157  			n.Logger.Printf("Esperando mensaje en %s...", n.Name)
   158  			message, err := socket.Recv(0)
   159  			if err != nil {
   160  				// Si ocurre un error al recibir el mensaje, loguea el error y termina el bucle.
   161  				n.Logger.Printf("Error al recibir mensaje: %v", err)
   162  				break
   163  			}
   164  			n.Logger.Printf("Mensaje recibido en %s: %v", n.Name, message)
   165  
   166  			// Llama al método HandleProcess, que es implementado por el tipo real de nodo (Follower, Leader, etc.).
   167  			// Este método procesará el mensaje recibido y generará una respuesta.
   168  			n.Logger.Printf("Procesando mensaje en %s...", n.Name)
   169  			response, err := n.Handler.HandleProcess(message)
   170  			if err != nil {
   171  				// Si hay un error al procesar el mensaje, loguea el error y termina el bucle.
   172  				n.Logger.Printf("Error en HandleProcess en %s: %v", n.Name, err)
   173  				break
   174  			}
   175  
   176  			// Envía la respuesta de vuelta al cliente a través del socket.
   177  			n.Logger.Printf("Enviando respuesta en %s: %v", n.Name, response)
   178  			_, err = socket.Send(response, 0)
   179  			if err != nil {
   180  				// Si ocurre un error al enviar la respuesta, loguea el error y termina el bucle.
   181  				n.Logger.Printf("Error al enviar respuesta en %s: %v", n.Name, err)
   182  				break
   183  			}
   184  		}
   185  	}()
   186  
   187  	// La función regresa nil si todo se configura correctamente y la goroutine se inicia sin errores.
   188  	n.Logger.Printf("Escucha iniciada exitosamente en el nodo %s", n.Name)
   189  	return nil
   190  }
   191  
   192  // Close cierra los recursos del nodo.
   193  func (n *AbstractNode) Close() error {
   194  	if n.Socket != nil {
   195  		n.Socket.Close()
   196  		n.Logger.Printf("Socket cerrado para el nodo %s", n.Name)
   197  	}
   198  	if n.Context != nil {
   199  		n.Context.Term()
   200  		n.Logger.Printf("Contexto cerrado para el nodo %s", n.Name)
   201  	}
   202  	return nil
   203  }
   204  
   205  // handleProcess debe ser sobrescrito por las subclases para procesar mensajes.
   206  func (n *AbstractNode) handleProcess(message string) string {
   207  	n.Logger.Printf("Procesando mensaje: %s", message)
   208  	return `{"status":"unhandled"}`
   209  }
   210  

View as plain text

Source file src/goberkeley/berkeley/config.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"os"
     7  	"time"
     8  )
     9  
    10  type LeaderConfig struct {
    11  	Name    string `json:"name"`
    12  	Address string `json:"address"`
    13  }
    14  
    15  type FollowerConfig struct {
    16  	Name    string `json:"name"`
    17  	Address string `json:"address"`
    18  }
    19  
    20  type Config struct {
    21  	Leader    LeaderConfig     `json:"leader"`
    22  	Followers []FollowerConfig `json:"followers"`
    23  	Timeout   time.Duration    `json:"timeout"`
    24  }
    25  
    26  func LoadConfig(filepath string) *Config {
    27  	// Abrir el archivo JSON
    28  	file, err := os.Open(filepath)
    29  	if err != nil {
    30  		fmt.Println("Error abriendo el archivo:", err)
    31  		return nil
    32  	}
    33  	defer file.Close()
    34  
    35  	// Decodificar el JSON en la estructura Config
    36  	var config Config
    37  	decoder := json.NewDecoder(file)
    38  	if err := decoder.Decode(&config); err != nil {
    39  		fmt.Println("Error decodificando JSON:", err)
    40  		return nil
    41  	}
    42  
    43  	// Imprimir la configuración cargada
    44  	fmt.Printf("Líder: %s (%s)\n", config.Leader.Name, config.Leader.Address)
    45  	for _, follower := range config.Followers {
    46  		fmt.Printf("Seguidor: %s (%s)\n", follower.Name, follower.Address)
    47  	}
    48  	fmt.Printf("Timeout: %d ms\n", config.Timeout)
    49  
    50  	return &config
    51  }
    52  

View as plain text

Source file src/goberkeley/berkeley/follower.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"log"
     8  	"time"
     9  )
    10  
    11  // Follower representa un nodo seguidor en el sistema distribuido.
    12  type Follower struct {
    13  	aAbstractNode *AbstractNode
    14  	LeaderAddress string
    15  }
    16  
    17  // InitializeNode inicializa el nodo seguidor con su información específica.
    18  func InitializeFollowerNode(name, address, leaderAddress string, timeout time.Duration) (*Follower, error) {
    19  	// Asegúrate de llamar al método correcto de AbstractNode.
    20  
    21  	f, err := NewFollower(name, address, leaderAddress, timeout)
    22  	if err != nil {
    23  		return nil, err
    24  	}
    25  
    26  	return f, nil
    27  }
    28  
    29  // NewFollower crea e inicializa un nuevo nodo seguidor.
    30  func NewFollower(name, address, leaderAddress string, timeout time.Duration) (*Follower, error) {
    31  	// Inicializar el nodo abstracto usando NewAbstractNode
    32  	abstractNode, err := NewAbstractNode(name, address, timeout)
    33  	if err != nil {
    34  		return nil, err
    35  	}
    36  
    37  	// Crear e inicializar la estructura Follower
    38  	follower := &Follower{
    39  		aAbstractNode: abstractNode,
    40  		LeaderAddress: leaderAddress,
    41  	}
    42  	follower.aAbstractNode.Handler = follower
    43  	return follower, nil
    44  }
    45  
    46  // HandleProcess maneja y procesa los mensajes recibidos del líder.
    47  // Implementación de HandleProcess para Follower
    48  func (f *Follower) HandleProcess(message string) (string, error) {
    49  	log.Printf("Recibiendo mensaje del líder: %s", message) // Traza para ver el mensaje recibido
    50  
    51  	// Deserialización del mensaje JSON
    52  	var data map[string]interface{}
    53  	if err := json.Unmarshal([]byte(message), &data); err != nil {
    54  		log.Printf("Error al deserializar el mensaje JSON: %v", err)
    55  		return `{"error":"Error al procesar el mensaje JSON"}`, nil
    56  	}
    57  	log.Printf("Mensaje deserializado correctamente: %+v", data) // Traza para mostrar el mensaje deserializado
    58  
    59  	// Extraer los campos del mensaje deserializado
    60  	leaderAddr := data["leader_address"].(string)
    61  	operation := data["operation"].(string)
    62  	leaderMessage := data["message"].(string)
    63  
    64  	log.Printf("Procesando mensaje del líder: %s desde %s con operación: %s", leaderAddr, f.LeaderAddress, operation)
    65  
    66  	// Procesar según la operación especificada
    67  	switch operation {
    68  	case "GET_TIME":
    69  		// Acceder a 'time' y asegurar su tipo como float64
    70  		T0Float, ok := data["time"].(float64)
    71  		if !ok {
    72  			log.Printf("Error al convertir data[\"time\"] a float64")
    73  			return "", errors.New("Error al procesar el campo Time")
    74  		}
    75  
    76  		// Convertir de float64 a int64
    77  		T0 := int64(T0Float)
    78  
    79  		log.Printf("T0 recibido: %d", T0)
    80  		currentTime := f.getCurrentTime()
    81  
    82  		log.Printf("Operación GET_TIME: T0 recibido %d, Hora local calculada: %d", T0, currentTime) // Traza para tiempo
    83  
    84  		// Llamada a la función que maneja el mensaje del líder y muestra su mensaje
    85  		TP := f.displayLeaderMessage(leaderAddr, leaderMessage, T0, currentTime)
    86  		log.Printf("Hora procesada TP: %d", TP) // Traza para TP
    87  
    88  		// Responder con el formato esperado
    89  		return fmt.Sprintf(`{"followerName":"%s", "localTime":"%d", "addressFollower":"%s"}`, f.aAbstractNode.Name, TP, f.aAbstractNode.Address), nil
    90  	case "UPDATE_TIME":
    91  		delta := int64(data["delta"].(float64))
    92  		log.Printf("Operación UPDATE_TIME: Delta recibido: %d", delta) // Traza para delta
    93  
    94  		// Modificar el sistema según el delta
    95  		return f.modSystemTime(delta), nil
    96  	case "CLOSE":
    97  		log.Printf("Operación CLOSE: Cerrando seguidor %s", f.aAbstractNode.Name) // Traza para CLOSE
    98  		return fmt.Sprintf(`{"followerName":"%s","operation":"CLOSE"}`, f.aAbstractNode.Name), nil
    99  	default:
   100  		log.Printf("Operación no reconocida en el mensaje del líder: %s", operation) // Traza para operación no reconocida
   101  		return `{"error":"Operación no reconocida"}`, nil
   102  	}
   103  }
   104  
   105  // displayLeaderMessage muestra el mensaje del líder y calcula un tiempo promedio (TP).
   106  func (f *Follower) displayLeaderMessage(leaderAddr, leaderMessage string, T0, localTime int64) int64 {
   107  	log.Printf("Mensaje del líder con dirección (%s) recibido: %s con T0 %s", leaderAddr, leaderMessage, time.UnixMilli(T0).String())
   108  	TP := (T0 + localTime) / 2
   109  	log.Printf("TP del seguidor %s es %s", f.aAbstractNode.Name, time.UnixMilli(TP).String())
   110  	return TP
   111  }
   112  
   113  // modSystemTime modifica el tiempo local del sistema basado en un delta.
   114  func (f *Follower) modSystemTime(delta int64) string {
   115  	currentLocalTime := time.Now().UnixMilli()
   116  	modSystemTime := currentLocalTime + delta
   117  	log.Printf("Tiempo del seguidor %s modificado de %s a %s", f.aAbstractNode.Name, time.UnixMilli(currentLocalTime).String(), time.UnixMilli(modSystemTime).String())
   118  	return fmt.Sprintf(`{"followerName":"%s", "localTime":"%d","operation":"OK_MOD_TIME"}`, f.aAbstractNode.Name, modSystemTime)
   119  }
   120  
   121  // getCurrentTime obtiene la hora actual del sistema en milisegundos desde la época Unix.
   122  func (f *Follower) getCurrentTime() int64 {
   123  	TP := time.Now().UnixMilli()
   124  	log.Printf("Fecha y hora local del seguidor: TP: %s", time.UnixMilli(TP).String())
   125  	return TP
   126  }
   127  
   128  // StartAlgorithm configura e inicia el socket REP para escuchar mensajes entrantes
   129  // y delega la responsabilidad de iniciar la escucha al nodo abstracto.
   130  // StartAlgorithm configura e inicia la escucha en el seguidor
   131  func (f *Follower) StartAlgorithm() error {
   132  	// Llama a StartListening, que se encargará de la creación y enlace del socket.
   133  	log.Printf("Iniciando algoritmo para el seguidor %s en %s", f.aAbstractNode.Name, f.aAbstractNode.Address)
   134  	return f.aAbstractNode.StartListening()
   135  }
   136  

View as plain text

Source file src/goberkeley/berkeley/follower_info.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  )
     7  
     8  // FollowerInfo encapsula información sobre un nodo seguidor en el sistema.
     9  type FollowerInfo struct {
    10  	Name              string        // Nombre del seguidor
    11  	Address           string        // Dirección del seguidor en formato "host:puerto"
    12  	State             FollowerState // Estado actual del seguidor
    13  	DateFollower      time.Time     // Fecha y hora local del seguidor
    14  	LocalTime         int64         // Hora local del seguidor en milisegundos desde la época UNIX
    15  	CommunicationTime int64         // Tiempo de comunicación entre líder y seguidor en milisegundos
    16  	TripTime          int64         // Tiempo de ida y vuelta (triptime) estimado
    17  	DiffTime          int64         // Diferencia de tiempo calculada entre líder y seguidor
    18  	Delta             int64         // Diferencia global de tiempo (delta) aplicada al seguidor
    19  }
    20  
    21  // NewFollowerInfo crea un nuevo objeto FollowerInfo con los valores proporcionados.
    22  func NewFollowerInfo(address, name string, localTime, communicationTime, nowTime int64) *FollowerInfo {
    23  	tripTime := communicationTime / 2
    24  	diffTime := (localTime + tripTime) - nowTime
    25  
    26  	return &FollowerInfo{
    27  		Name:              name,
    28  		Address:           address,
    29  		LocalTime:         localTime,
    30  		CommunicationTime: communicationTime,
    31  		TripTime:          tripTime,
    32  		DiffTime:          diffTime,
    33  		State:             RequestNotSent, // Estado inicial por defecto
    34  	}
    35  }
    36  
    37  // GetAddress devuelve la dirección del seguidor.
    38  func (f *FollowerInfo) GetAddress() string {
    39  	return f.Address
    40  }
    41  
    42  // GetName devuelve el nombre del seguidor.
    43  func (f *FollowerInfo) GetName() string {
    44  	return f.Name
    45  }
    46  
    47  // GetDateFollower devuelve la fecha y hora local del seguidor.
    48  func (f *FollowerInfo) GetDateFollower() time.Time {
    49  	return f.DateFollower
    50  }
    51  
    52  // GetDiffTime devuelve la diferencia de tiempo entre el líder y el seguidor.
    53  func (f *FollowerInfo) GetDiffTime() int64 {
    54  	return f.DiffTime
    55  }
    56  
    57  // GetLocalTime devuelve la hora local del seguidor.
    58  func (f *FollowerInfo) GetLocalTime() int64 {
    59  	return f.LocalTime
    60  }
    61  
    62  // GetCommunicationTime devuelve el tiempo de comunicación entre líder y seguidor.
    63  func (f *FollowerInfo) GetCommunicationTime() int64 {
    64  	return f.CommunicationTime
    65  }
    66  
    67  // GetDelta devuelve la diferencia global de tiempo (delta).
    68  func (f *FollowerInfo) GetDelta() int64 {
    69  	return f.Delta
    70  }
    71  
    72  // SetDelta establece la diferencia global de tiempo (delta) para el seguidor.
    73  func (f *FollowerInfo) SetDelta(delta int64) {
    74  	f.Delta = delta
    75  }
    76  
    77  // GetState devuelve el estado actual del seguidor.
    78  func (f *FollowerInfo) GetState() FollowerState {
    79  	return f.State
    80  }
    81  
    82  // SetState establece el estado del seguidor.
    83  func (f *FollowerInfo) SetState(state FollowerState) {
    84  	f.State = state
    85  }
    86  
    87  // String genera una representación en cadena del objeto FollowerInfo.
    88  func (f *FollowerInfo) String() string {
    89  	return fmt.Sprintf("Nombre: %s, Estado: %s, Hora local: %d, Fecha: %s, "+
    90  		"Tiempo de comunicación: %d ms, TripTime: %d ms, Diferencia de tiempo: %d ms, "+
    91  		"Diferencia global (delta): %d ms, Dirección: %s",
    92  		f.Name, f.State, f.LocalTime, f.DateFollower, f.CommunicationTime,
    93  		f.TripTime, f.DiffTime, f.Delta, f.Address)
    94  }
    95  

View as plain text

Source file src/goberkeley/berkeley/follower_state.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  // FollowerState representa los posibles estados de un seguidor durante el proceso de actualización de la hora del sistema.
     4  type FollowerState string
     5  
     6  const (
     7  	// RESPONDED indica que el seguidor ha respondido correctamente a la solicitud del líder.
     8  	Responded FollowerState = "RESPONDED"
     9  
    10  	// NO_RESPONSE indica que el seguidor no ha respondido a la solicitud dentro del tiempo esperado.
    11  	NoResponse FollowerState = "NO_RESPONSE"
    12  
    13  	// CONNECTION_ERROR indica que hubo un error de conexión al intentar comunicarse con el seguidor.
    14  	ConnectionError FollowerState = "CONNECTION_ERROR"
    15  
    16  	// REQUEST_NOT_SENT indica que la solicitud de actualización de la hora no fue enviada debido a algún error.
    17  	RequestNotSent FollowerState = "REQUEST_NOT_SENT"
    18  
    19  	// REQUEST_DELTA_SENT indica que la solicitud de actualización de la hora fue enviada al seguidor para actualizar su hora.
    20  	RequestDeltaSent FollowerState = "REQUEST_DELTA_SENT"
    21  
    22  	// TIME_ERROR_SENT_UPDATE indica que la solicitud de actualización de la hora fue enviada pero hubo un error en ese envío.
    23  	TimeErrorSentUpdate FollowerState = "TIME_ERROR_SENT_UPDATE"
    24  
    25  	// TIME_UPDATED indica que la hora del sistema del seguidor se actualizó correctamente.
    26  	TimeUpdated FollowerState = "TIME_UPDATED"
    27  
    28  	// ERROR_CLOSE indica que  no pude enviar el cierre del socket en el seguidor.
    29  	ErrorClose FollowerState = "ERROR_CLOSE"
    30  
    31  	// Ok_CLOSE indica que   pude  cerrar el socket en el seguidor.
    32  	OkClose FollowerState = "Ok_CLOSE"
    33  )
    34  

View as plain text

Source file src/goberkeley/berkeley/inode.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"time"
     5  )
     6  
     7  // INode define las operaciones básicas para un nodo en el sistema.
     8  type INode interface {
     9  	InitializeNode(name string, address string, timeout time.Duration) error
    10  	InitializeNodeWithAddresses(name string, address string, timeout time.Duration, addresses map[string]string) error
    11  	SendMessageSync(address string, message string) (string, error)
    12  	SendMessageAsync(address string, message string) error
    13  	StartListening() error
    14  	StartAlgorithm() error
    15  	Close() error
    16  }
    17  

View as plain text

Source file src/goberkeley/berkeley/leader.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  
     7  	"log"
     8  	"strconv"
     9  	"sync"
    10  	"time"
    11  )
    12  
    13  // Mensaje JSON que se envía al seguidor.
    14  type TimeRequest struct {
    15  	Message    string `json:"message"`
    16  	Operation  string `json:"operation"`
    17  	Time       int64  `json:"time"`
    18  	LeaderAddr string `json:"leader_address"`
    19  }
    20  type DeltaRequest struct {
    21  	Message    string `json:"message"`
    22  	Operation  string `json:"operation"`
    23  	Delta      int64  `json:"delta"`
    24  	LeaderAddr string `json:"leader_address"`
    25  }
    26  type closeRequest struct {
    27  	Message    string `json:"message"`
    28  	Operation  string `json:"operation"`
    29  	LeaderAddr string `json:"leader_address"`
    30  }
    31  
    32  // Leader representa el nodo líder en el sistema Berkeley.
    33  type Leader struct {
    34  	aAbstractNode          *AbstractNode
    35  	UnreachableFollowers   map[string]*FollowerInfo
    36  	SuccessfulFollowers    map[string]*FollowerInfo
    37  	NonRespondingFollowers map[string]*FollowerInfo
    38  	TimeUpdatedFollowers   map[string]*FollowerInfo
    39  	FailedFollowers        map[string]*FollowerInfo
    40  	//mu                     sync.Mutex // Mutex para proteger los mapas en accesos concurrentes
    41  	Logger *log.Logger
    42  }
    43  
    44  // HandleProcess implements Handler.
    45  func (l *Leader) HandleProcess(message string) (string, error) {
    46  	panic("unimplemented")
    47  }
    48  
    49  // InitializeLeaderNode crea e inicializa un nuevo nodo líder.
    50  func InitializeLeaderNode(name, address string, timeout time.Duration, nodeAddresses map[string]string) (*Leader, error) {
    51  	// Suponiendo que InitializeNodeWithAddresses crea un nodo base y devuelve un puntero a AbstractNode
    52  	baseNode, err := InitializeNodeWithAddresses(name, address, timeout, nodeAddresses)
    53  	if err != nil {
    54  		return nil, err
    55  	}
    56  
    57  	// Inicializamos el líder, asignando el nodo base y un logger
    58  	leader := &Leader{
    59  		aAbstractNode: baseNode, // Asignamos el puntero a AbstractNode
    60  		Logger:        log.Default(),
    61  	}
    62  	leader.aAbstractNode.Handler = leader
    63  
    64  	return leader, nil
    65  }
    66  func (l *Leader) initStructs() {
    67  	if l.UnreachableFollowers == nil {
    68  		l.UnreachableFollowers = make(map[string]*FollowerInfo)
    69  	}
    70  	if l.SuccessfulFollowers == nil {
    71  		l.SuccessfulFollowers = make(map[string]*FollowerInfo)
    72  	}
    73  	if l.NonRespondingFollowers == nil {
    74  		l.NonRespondingFollowers = make(map[string]*FollowerInfo)
    75  	}
    76  	if l.TimeUpdatedFollowers == nil {
    77  		l.TimeUpdatedFollowers = make(map[string]*FollowerInfo)
    78  	}
    79  	if l.FailedFollowers == nil {
    80  		l.FailedFollowers = make(map[string]*FollowerInfo)
    81  	}
    82  }
    83  
    84  // StartAlgorithm implementa el algoritmo de sincronización Berkeley para el líder.
    85  func (l *Leader) StartAlgorithm() {
    86  	l.Logger.Println("Iniciando algoritmo de sincronización Berkeley...")
    87  	l.initStructs()
    88  	// Simula el envío de solicitudes de tiempo a los seguidores
    89  	l.processFollowers()
    90  
    91  	// Fase 2: Calcular el delta con la media de los tiempos
    92  	log.Println("** Fase 2 **: Calcular el delta con la media de los tiempos")
    93  	delta := l.calculateDeltaTimeDifference()
    94  	if delta != 0 {
    95  		// Paso 3: Actualizar relojes de los seguidores
    96  		log.Println("** Paso 3 **: Llamar a los seguidores para actualizar sus relojes")
    97  		l.callFollowersWithUpdatedTime(delta)
    98  
    99  		// Fase 4: Enviar mensaje de cierre
   100  		log.Println("** Fase 4 **: Enviar mensaje de cierre a los seguidores")
   101  		l.sendCloseMessagesToFollowers()
   102  
   103  		// Fase 5: Mostrar los resultados finales
   104  		log.Println("** Fase 5: Mostrar los resultados de la sincronización")
   105  		l.printResults()
   106  	} else {
   107  		// Se registra esta situación para comprobarlo más adelante en los logs
   108  		log.Println("El resultado del delta es cero por lo que no se envían actualizaciones a ningún seguidor.")
   109  	}
   110  }
   111  func (l *Leader) processFollowers() {
   112  	leaderTime := time.Now().UnixMilli() // T0
   113  	leaderAddr := l.aAbstractNode.Address
   114  
   115  	log.Printf("processFollowers: leaderAddr %s leaderTime %d.", leaderAddr, leaderTime)
   116  
   117  	// Lista de seguidores
   118  	followers := l.aAbstractNode.NodeAddresses
   119  
   120  	// Canal para los resultados
   121  	results := make(chan *FollowerInfo, len(followers))
   122  	var wg sync.WaitGroup
   123  
   124  	// Enviar solicitudes a los seguidores concurrentemente
   125  	for followerName, followerAddr := range followers {
   126  		wg.Add(1)
   127  		go func(name, addr string) {
   128  			defer wg.Done()
   129  			log.Printf("Enviando solicitud de tiempo a %s (%s).", name, addr)
   130  			l.sendTimeRequestToFollower(name, addr, leaderTime, leaderAddr, results)
   131  		}(followerName, followerAddr)
   132  	}
   133  
   134  	// Cerrar el canal una vez que todos los goroutines hayan terminado
   135  	go func() {
   136  		wg.Wait()
   137  		close(results)
   138  	}()
   139  
   140  	// Recoger y procesar los resultados
   141  	for res := range results {
   142  		if res.GetState() == "RESPONDED" {
   143  			// Seguidor que respondió correctamente
   144  			l.SuccessfulFollowers[res.GetName()] = res
   145  			log.Printf("Seguidor %s respondió correctamente con tiempo local: %d ms", res.GetName(), res.GetLocalTime())
   146  		} else if res.GetState() == "TIMEOUT" {
   147  			// Seguidor que no respondió a tiempo
   148  			l.NonRespondingFollowers[res.GetName()] = res
   149  			log.Printf("Seguidor %s no respondió a tiempo.", res.GetName())
   150  		} else {
   151  			// Seguidor que tuvo algún otro problema
   152  			l.FailedFollowers[res.GetName()] = res
   153  			log.Printf("Seguidor %s falló con estado: %s.", res.GetName(), res.GetState())
   154  		}
   155  	}
   156  
   157  	// Log final para indicar que el procesamiento de seguidores ha terminado
   158  	log.Printf("Proceso de seguidores completado. Respuestas procesadas: %d, Fallos: %d.", len(l.SuccessfulFollowers), len(l.NonRespondingFollowers))
   159  }
   160  func (l *Leader) sendTimeRequestToFollower(followerName, followerAddr string, leaderTime int64, leaderAddr string, results chan<- *FollowerInfo) {
   161  	// Crear el mensaje JSON
   162  	request := TimeRequest{
   163  		Message:    "Requesting time sync",
   164  		Operation:  "GET_TIME",
   165  		Time:       leaderTime, //T0
   166  		LeaderAddr: leaderAddr,
   167  	}
   168  
   169  	// Serializar el mensaje en formato JSON
   170  	requestData, err := json.Marshal(request)
   171  	if err != nil {
   172  		log.Printf("Error al serializar la solicitud a JSON: %v", err)
   173  		results <- NewFollowerInfo(followerAddr, followerName, 0, 0, 0)
   174  		return
   175  	}
   176  
   177  	// Convertir el JSON a string
   178  	requestString := string(requestData)
   179  	log.Printf("Solicitud enviada a %s: %s", followerAddr, requestString)
   180  
   181  	// Enviar el mensaje al seguidor y recibir la respuesta
   182  	reply, err := l.aAbstractNode.SendMessageSync(followerAddr, requestString)
   183  	if err != nil {
   184  		log.Printf("Error al recibir respuesta de %s: %v", followerAddr, err)
   185  		followError := NewFollowerInfo(followerAddr, followerName, 0, 0, 0)
   186  		results <- followError
   187  		return
   188  	}
   189  
   190  	log.Printf("Respuesta recibida de %s: %s", followerAddr, reply)
   191  
   192  	// Deserializar la respuesta JSON
   193  	var response map[string]string
   194  	if err := json.Unmarshal([]byte(reply), &response); err != nil {
   195  		log.Printf("Error al procesar la respuesta de %s: %v", followerAddr, err)
   196  		results <- NewFollowerInfo(followerAddr, followerName, 0, 0, 0)
   197  		return
   198  	}
   199  
   200  	// Calcular la diferencia de tiempo
   201  	endCommTime := time.Now().UnixMilli() // T0
   202  	timeComm := endCommTime - leaderTime
   203  	log.Printf("Tiempo de comunicación: %d ms", timeComm)
   204  
   205  	// Obtener el tiempo local del seguidor
   206  	localTimeStr, ok := response["localTime"]
   207  	if !ok {
   208  		log.Printf("No se encontró el campo 'localTime' en la respuesta de %s", followerAddr)
   209  		results <- NewFollowerInfo(followerAddr, followerName, 0, 0, 0)
   210  		return
   211  	}
   212  
   213  	// Convertir el valor de localTime de string a int64
   214  	localTimeInt64, err := strconv.ParseInt(localTimeStr, 10, 64)
   215  	if err != nil {
   216  		log.Printf("Error al convertir 'localTime' a int64 de %s: %v", followerAddr, err)
   217  		results <- NewFollowerInfo(followerAddr, followerName, 0, 0, 0)
   218  		return
   219  	}
   220  
   221  	// Enviar los resultados al canal
   222  	log.Printf("Tiempo local recibido de %s: %d", followerAddr, localTimeInt64)
   223  	foll := NewFollowerInfo(followerAddr, followerName, localTimeInt64, timeComm, 0)
   224  	foll.SetState(Responded)
   225  	results <- foll
   226  }
   227  
   228  // calculateDeltaTimeDifference calcula la diferencia de tiempo (delta) entre el tiempo local y los tiempos de los seguidores válidos.
   229  func (l *Leader) calculateDeltaTimeDifference() int64 {
   230  	// Log de inicio de la operación de cálculo de la diferencia de tiempo
   231  	log.Println("Calculando la diferencia de tiempo (delta)")
   232  
   233  	// Obtener el tiempo actual del líder
   234  	now := time.Now().UnixMilli()
   235  	var sumTime int64 = 0           // Suma de los tiempos ajustados de los seguidores
   236  	var validFollowersCount int = 0 // Contador de seguidores con respuestas válidas
   237  
   238  	// Recorrer los seguidores exitosos y calcular la diferencia de tiempo para cada uno
   239  	for _, follower := range l.SuccessfulFollowers {
   240  		if follower.DiffTime != int64(^uint64(0)>>1) { // Verificar si el seguidor tiene un tiempo válido (Long.MAX_VALUE en Java)
   241  			followerTime := now + follower.DiffTime // Calcular el tiempo ajustado del seguidor
   242  			sumTime += followerTime                 // Sumar el tiempo ajustado
   243  			validFollowersCount++                   // Incrementar el contador de seguidores válidos
   244  		}
   245  	}
   246  
   247  	// Si se tienen seguidores válidos, calcular la diferencia de tiempo promedio
   248  	if validFollowersCount > 0 {
   249  		newNow := sumTime / int64(validFollowersCount) // Calcular el promedio de los tiempos de los seguidores
   250  		delta := newNow - now                          // Calcular la diferencia de tiempo (delta)
   251  
   252  		// Log de los resultados calculados
   253  		log.Printf("Nuevo tiempo calculado (new_now): %d\n", newNow)
   254  		log.Printf("Diferencia global (δ): %d\n", delta)
   255  
   256  		// Retornar la diferencia de tiempo (delta)
   257  		return delta
   258  	} else {
   259  		// Si no hay seguidores válidos, registrar advertencia y retornar 0
   260  		log.Println("No se han recibido respuestas válidas de los seguidores.")
   261  		return 0
   262  	}
   263  }
   264  
   265  func (l *Leader) callFollowersWithUpdatedTime(delta int64) error {
   266  	log.Printf("Enviando actualización de tiempo a los seguidores con delta: %d", delta)
   267  
   268  	// Crear un canal para gestionar las tareas concurrentes
   269  	ch := make(chan *FollowerInfo, len(l.SuccessfulFollowers))
   270  
   271  	// Usamos un WaitGroup para esperar que todas las goroutines terminen
   272  	var wg sync.WaitGroup
   273  
   274  	// Enviar las tareas en paralelo para cada seguidor
   275  	for _, follower := range l.SuccessfulFollowers {
   276  		wg.Add(1) // Incrementamos el contador del WaitGroup
   277  		go func(follower FollowerInfo) {
   278  			defer wg.Done() // Decrementamos el contador del WaitGroup cuando la goroutine termina
   279  			followerInfo := l.sendTimeUpdateToFollower(follower, delta)
   280  			ch <- followerInfo
   281  		}(*follower)
   282  	}
   283  
   284  	// Iniciar una goroutine para cerrar el canal una vez que todas las goroutines hayan terminado
   285  	go func() {
   286  		wg.Wait() // Esperamos a que todas las goroutines terminen
   287  		close(ch) // Cerramos el canal después de que todas las goroutines hayan enviado sus respuestas
   288  	}()
   289  
   290  	// Procesar las respuestas conforme vayan llegando
   291  	for followerInfo := range ch {
   292  		if followerInfo.State == "TIME_UPDATED" {
   293  			log.Printf("El seguidor %s respondió correctamente al cambio del timer.", followerInfo.Name)
   294  			l.TimeUpdatedFollowers[followerInfo.Name] = followerInfo
   295  		} else {
   296  			log.Printf("El seguidor %s no respondió al cambio de su timer.", followerInfo.Name)
   297  			l.FailedFollowers[followerInfo.Name] = followerInfo
   298  		}
   299  	}
   300  
   301  	return nil
   302  }
   303  
   304  func (l *Leader) sendTimeUpdateToFollower(follower FollowerInfo, delta int64) *FollowerInfo {
   305  
   306  	// Crear el mapa con la solicitud
   307  	request := DeltaRequest{
   308  		Message:    "Modifica el tiempo del sistema de tu servidor con el diferencial.",
   309  		Operation:  "UPDATE_TIME",
   310  		Delta:      delta,
   311  		LeaderAddr: l.aAbstractNode.Address,
   312  	}
   313  
   314  	// Serializar la solicitud a JSON
   315  	jsonRequest, err := json.Marshal(request)
   316  	if err != nil {
   317  		log.Printf("Error al serializar la solicitud para el seguidor %s: %v", follower.Name, err)
   318  		follower.State = TimeErrorSentUpdate
   319  		return &follower
   320  	}
   321  
   322  	requestString := string(jsonRequest)
   323  	log.Printf("Solicitud enviada a %s: %s", follower.GetAddress(), requestString)
   324  	// Enviar la solicitud
   325  	reply, err := l.aAbstractNode.SendMessageSync(follower.GetAddress(), requestString)
   326  	if err != nil {
   327  		log.Printf("Error al recibir respuesta de %s: %v", follower.GetAddress(), err)
   328  		followError := NewFollowerInfo(follower.GetAddress(), follower.GetName(), 0, 0, 0)
   329  		followError.State = TimeErrorSentUpdate
   330  		return followError
   331  	}
   332  
   333  	var response map[string]string
   334  	err = json.Unmarshal([]byte(reply), &response)
   335  	if err != nil {
   336  		log.Printf("Error al deserializar la respuesta del seguidor %s: %v", follower.Name, err)
   337  		follower.State = TimeErrorSentUpdate
   338  		return &follower
   339  	}
   340  
   341  	// Registrar la respuesta
   342  	followerName := response["followerName"]
   343  	operation := response["operation"]
   344  	log.Printf("Respuesta de %s: Operación %s exitosa", followerName, operation)
   345  
   346  	follower.State = TimeUpdated
   347  	return &follower
   348  }
   349  func (l *Leader) sendCloseMessagesToFollowers() {
   350  	// Crear un WaitGroup para esperar a que todas las goroutines terminen
   351  	var wg sync.WaitGroup
   352  
   353  	// Canal para recibir los resultados de las goroutines
   354  	resultCh := make(chan string, len(l.TimeUpdatedFollowers))
   355  
   356  	// Enviar mensaje de cierre a cada seguidor de manera concurrente
   357  	for _, follower := range l.TimeUpdatedFollowers {
   358  		wg.Add(1)
   359  		go func(follower FollowerInfo) {
   360  			defer wg.Done()
   361  
   362  			// Enviar el mensaje de cierre
   363  			err := l.sendCloseMessage(follower.Address, follower.Name)
   364  			if err != nil {
   365  				resultCh <- fmt.Sprintf("Error al enviar mensaje de cierre a %s: %s", follower.Name, err)
   366  				return
   367  			}
   368  
   369  			// Simulamos que el mensaje fue enviado exitosamente
   370  			resultCh <- fmt.Sprintf("Mensaje de cierre enviado con éxito a %s", follower.Name)
   371  		}(*follower)
   372  	}
   373  
   374  	// Esperar a que todas las goroutines terminen
   375  	go func() {
   376  		wg.Wait()
   377  		close(resultCh)
   378  	}()
   379  
   380  	// Procesar los resultados a medida que vayan llegando
   381  	for result := range resultCh {
   382  		log.Println(result)
   383  	}
   384  
   385  }
   386  
   387  // SendCloseMessage envía un mensaje de cierre a un seguidor.
   388  // Simulación de la función para enviar mensaje de cierre a un seguidor
   389  func (l *Leader) sendCloseMessage(followerAddress, followerName string) *FollowerInfo {
   390  	log.Printf("Enviando mensaje de cierre a %s...", followerAddress)
   391  
   392  	request := closeRequest{
   393  		Message:    "Cerrar conexión",
   394  		Operation:  "CLOSE",
   395  		LeaderAddr: l.aAbstractNode.Address,
   396  	}
   397  
   398  	// Convertir el mensaje a JSON
   399  	jsonRequest, err := json.Marshal(request)
   400  	if err != nil {
   401  		log.Printf("error al crear mensaje de cierre: %w", err)
   402  		followError := NewFollowerInfo(followerAddress, followerName, 0, 0, 0)
   403  		followError.State = ErrorClose
   404  		return followError
   405  	}
   406  
   407  	// Simulamos el envío del mensaje al seguidor (usando un canal)
   408  	log.Printf("Mensaje de cierre enviado a %s: %s", followerAddress, jsonRequest)
   409  	// Serializar la solicitud a JSON
   410  
   411  	requestString := string(jsonRequest)
   412  	log.Printf("Solicitud enviada a %s: %s", followerAddress, requestString)
   413  	// Enviar la solicitud
   414  	reply, err := l.aAbstractNode.SendMessageSync(followerAddress, requestString)
   415  	if err != nil {
   416  		log.Printf("Error al recibir respuesta de %s: %v", followerAddress, err)
   417  		followError := NewFollowerInfo(followerAddress, followerName, 0, 0, 0)
   418  		followError.State = ErrorClose
   419  		return followError
   420  	}
   421  
   422  	var response map[string]string
   423  	err = json.Unmarshal([]byte(reply), &response)
   424  	if err != nil {
   425  		log.Printf("Error al deserializar la respuesta del seguidor %s: %v", followerName, err)
   426  		followError := NewFollowerInfo(followerAddress, followerName, 0, 0, 0)
   427  		followError.State = ErrorClose
   428  		return followError
   429  	}
   430  	// Simulamos una respuesta (en un caso real recibirías la respuesta desde el socket)
   431  	// Aquí se simula un éxito.
   432  	response = map[string]string{
   433  		"followerName": followerAddress,
   434  		"operation":    "CLOSE",
   435  	}
   436  
   437  	// Convertimos la respuesta a JSON
   438  	jsonResponse, err := json.Marshal(response)
   439  	if err != nil {
   440  		log.Printf("error al procesar la respuesta: %w", err)
   441  		followError := NewFollowerInfo(followerAddress, followerName, 0, 0, 0)
   442  		followError.State = ErrorClose
   443  		return followError
   444  	}
   445  
   446  	// Simulamos la recepción de la respuesta (en un caso real, recibirías el mensaje desde el socket)
   447  	log.Printf("Respuesta recibida de %s: %s", followerAddress, jsonResponse)
   448  	follow := NewFollowerInfo(followerAddress, followerName, 0, 0, 0)
   449  	follow.State = OkClose
   450  	return follow
   451  }
   452  
   453  // PrintResults muestra los resultados del algoritmo.
   454  func (l *Leader) printResults() {
   455  	l.Logger.Println("Resultados del algoritmo Berkeley:")
   456  
   457  	// Mostrar seguidores inalcanzables
   458  	l.Logger.Println("Seguidores inalcanzables:")
   459  	for key, value := range l.UnreachableFollowers {
   460  		l.Logger.Printf("- %s: %v", key, value)
   461  	}
   462  
   463  	// Mostrar seguidores que no respondieron a tiempo
   464  	l.Logger.Println("Seguidores que no respondieron a tiempo:")
   465  	for key, value := range l.NonRespondingFollowers {
   466  		l.Logger.Printf("- %s: %v", key, value)
   467  	}
   468  
   469  	// Mostrar seguidores que respondieron correctamente
   470  	l.Logger.Println("Seguidores que respondieron correctamente:")
   471  	for key, value := range l.SuccessfulFollowers {
   472  		l.Logger.Printf("- %s: %v", key, value)
   473  	}
   474  
   475  	// Mostrar seguidores que actualizaron su tiempo correctamente
   476  	l.Logger.Println("Seguidores que actualizaron su tiempo correctamente:")
   477  	for key, value := range l.TimeUpdatedFollowers {
   478  		l.Logger.Printf("- %s: %v", key, value)
   479  	}
   480  
   481  	// Mostrar seguidores que no pudieron actualizar su tiempo
   482  	l.Logger.Println("Seguidores que no pudieron actualizar su tiempo:")
   483  	for key, value := range l.FailedFollowers {
   484  		l.Logger.Printf("- %s: %v", key, value)
   485  	}
   486  }
   487  func (l *Leader) Close() {
   488  	l.aAbstractNode.Close()
   489  }
   490  

View as plain text

Source file src/goberkeley/berkeley/logger_manager.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"github.com/sirupsen/logrus"
     5  	"reflect"
     6  )
     7  
     8  // LoggerManager es responsable de gestionar los loggers para las clases que lo invocan.
     9  type LoggerManager struct{}
    10  
    11  // GetLogger obtiene el logger correspondiente a la clase que invoca este método.
    12  func (LoggerManager) GetLogger(clazz interface{}) *logrus.Logger {
    13  	// Se usa el nombre de la clase (tipo) como parte del nombre del logger.
    14  	logger := logrus.New()
    15  
    16  	// Se asigna el nombre del tipo (nombre de la clase)
    17  	logger.SetFormatter(&logrus.TextFormatter{
    18  		FullTimestamp: true,
    19  	})
    20  	logger.SetLevel(logrus.InfoLevel)
    21  
    22  	className := reflect.TypeOf(clazz).Name()
    23  	logger.Infof("Logger for %s initialized.", className)
    24  
    25  	return logger
    26  }
    27  

View as plain text

Source file src/goberkeley/berkeley/socket_zero_mq_exception.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"fmt"
     5  )
     6  
     7  // ErrorType enum para los diferentes tipos de errores posibles en ZeroMQ.
     8  type ErrorType int
     9  
    10  const (
    11  	// CONNECTION_ERROR Error relacionado con la conexión de ZeroMQ
    12  	CONNECTION_ERROR ErrorType = iota
    13  	// SEND_ERROR Error al enviar un mensaje a través del socket
    14  	SEND_ERROR
    15  	// RECEIVE_ERROR Error al recibir un mensaje del socket
    16  	RECEIVE_ERROR
    17  )
    18  
    19  // SocketZeroMQException estructura que encapsula un error personalizado para ZeroMQ.
    20  type SocketZeroMQException struct {
    21  	Message   string    // Mensaje de error
    22  	ErrorType ErrorType // Tipo de error
    23  }
    24  
    25  // NewSocketZeroMQException crea una nueva instancia de SocketZeroMQException.
    26  func NewSocketZeroMQException(message string, errorType ErrorType) *SocketZeroMQException {
    27  	return &SocketZeroMQException{
    28  		Message:   message,
    29  		ErrorType: errorType,
    30  	}
    31  }
    32  
    33  // Error implementación de la interfaz error para SocketZeroMQException.
    34  func (e *SocketZeroMQException) Error() string {
    35  	return fmt.Sprintf("Error: %s, Tipo de error: %v", e.Message, e.ErrorType)
    36  }
    37  
    38  // GetErrorType obtiene el tipo de error.
    39  func (e *SocketZeroMQException) GetErrorType() ErrorType {
    40  	return e.ErrorType
    41  }
    42  

View as plain text

Source file src/goberkeley/berkeley/anode.go

Documentation: goberkeley/berkeley

     1  package berkeley
     2  
     3  import (
     4  	"errors"
     5  	"log"
     6  	"time"
     7  
     8  	zmq "github.com/pebbe/zmq4" // Librería para trabajar con ZeroMQ
     9  )
    10  
    11  // Interfaz Handler con el método HandleProcess
    12  type Handler interface {
    13  	HandleProcess(message string) (string, error)
    14  }
    15  
    16  // AbstractNode proporciona la funcionalidad base para nodos en el sistema.
    17  type AbstractNode struct {
    18  	Name          string
    19  	Address       string
    20  	Timeout       time.Duration
    21  	NodeAddresses map[string]string
    22  	Context       *zmq.Context
    23  	Socket        *zmq.Socket
    24  	Logger        *log.Logger
    25  	Handler       // Composición de la interfaz Handler
    26  }
    27  
    28  // NewAbstractNode crea e inicializa un nuevo nodo base.
    29  func NewAbstractNode(name, address string, timeout time.Duration) (*AbstractNode, error) {
    30  	context, err := zmq.NewContext()
    31  	if err != nil {
    32  		return nil, errors.New("error al crear el contexto ZeroMQ")
    33  	}
    34  
    35  	return &AbstractNode{
    36  		Name:    name,
    37  		Address: address,
    38  		Timeout: timeout,
    39  		Context: context,
    40  		Logger:  log.Default(),
    41  	}, nil
    42  }
    43  
    44  // InitializeNodeWithAddresses inicializa un nodo con direcciones de otros nodos.
    45  func InitializeNodeWithAddresses(name, address string, timeout time.Duration, addresses map[string]string) (*AbstractNode, error) {
    46  	var n *AbstractNode
    47  	n, err := NewAbstractNode(name, address, timeout)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	n.NodeAddresses = addresses
    52  	n.Logger.Printf("Nodo %s inicializado con direcciones %v", n.Name, addresses)
    53  	return n, nil
    54  }
    55  
    56  // SendMessageSync envía un mensaje de forma síncrona y espera una respuesta.
    57  func (n *AbstractNode) SendMessageSync(address string, message string) (string, error) {
    58  	// Creación del socket REQ (Request) para enviar el mensaje
    59  	var socket *zmq.Socket
    60  	socket, err := n.Context.NewSocket(zmq.REQ)
    61  	if err != nil {
    62  		n.Logger.Printf("Error al crear el socket REQ: %v", err) // Traza adicional
    63  		return "", errors.New("error al crear el socket REQ")
    64  	}
    65  	defer socket.Close()
    66  
    67  	// Establecer el timeout para recibir respuestas
    68  	socket.SetRcvtimeo(n.Timeout * time.Millisecond) // Convertir el timeout a milisegundos
    69  
    70  	// Traza: Mostrar el valor del timeout configurado
    71  	n.Logger.Printf("Timeout de recepción configurado a: %v milisegundos", int64(n.Timeout)) // Traza para el timeout
    72  
    73  	// Conectar al socket en la dirección proporcionada
    74  	err = socket.Connect("tcp://" + address)
    75  	if err != nil {
    76  		n.Logger.Printf("Error al conectar con %s: %v", address, err) // Traza adicional
    77  		return "", errors.New("error al conectar con " + address)
    78  	}
    79  
    80  	n.Logger.Printf("Conectado a %s", address) // Traza para verificar la conexión
    81  
    82  	// Enviar el mensaje al servidor
    83  	_, err = socket.Send(message, 0)
    84  	if err != nil {
    85  		n.Logger.Printf("Error al enviar el mensaje a %s: %v", address, err) // Traza adicional
    86  		return "", errors.New("error al enviar el mensaje")
    87  	}
    88  
    89  	n.Logger.Printf("Mensaje enviado a %s: %s", address, message) // Traza de envío
    90  
    91  	// Intentar recibir la respuesta
    92  	reply, err := socket.Recv(0)
    93  	if err != nil {
    94  		n.Logger.Printf("Error al recibir respuesta de %s: %v", address, err) // Traza para el error de recepción
    95  		return "", errors.New("no se recibió respuesta del socket")
    96  	}
    97  
    98  	n.Logger.Printf("Respuesta recibida de %s: %s", address, reply) // Traza de respuesta recibida
    99  	return reply, nil
   100  }
   101  
   102  // SendMessageAsync envía un mensaje de manera asíncrona.
   103  func (n *AbstractNode) SendMessageAsync(address, message string) error {
   104  	socket, err := n.Context.NewSocket(zmq.PUSH)
   105  	if err != nil {
   106  		return errors.New("error al crear el socket PUSH")
   107  	}
   108  	defer socket.Close()
   109  
   110  	err = socket.Connect("tcp://" + address)
   111  	if err != nil {
   112  		return errors.New("error al conectar con " + address)
   113  	}
   114  
   115  	_, err = socket.Send(message, 0)
   116  	if err != nil {
   117  		return errors.New("error al enviar el mensaje")
   118  	}
   119  
   120  	n.Logger.Printf("Mensaje asincrónico enviado a %s: %s", address, message)
   121  	return nil
   122  }
   123  
   124  // StartListening inicia el proceso de escucha para mensajes entrantes en el nodo.
   125  // Configura un socket de tipo REP (Response) para recibir y responder a mensajes.
   126  func (n *AbstractNode) StartListening() error {
   127  	// Log para indicar que estamos intentando crear un socket REP.
   128  	n.Logger.Printf("Intentando crear un socket REP para el nodo %s en la dirección %s", n.Name, n.Address)
   129  	socket, err := n.Context.NewSocket(zmq.REP)
   130  	if err != nil {
   131  		// Si ocurre un error al crear el socket, loguea el error y retorna un mensaje de error.
   132  		n.Logger.Printf("Error al crear el socket REP: %v", err)
   133  		return errors.New("error al crear el socket REP")
   134  	}
   135  	n.Socket = socket
   136  	n.Logger.Printf("Socket REP creado exitosamente para el nodo %s", n.Name)
   137  
   138  	// Enlaza el socket a la dirección TCP proporcionada en el nodo para esperar conexiones.
   139  	n.Logger.Printf("Enlazando el socket REP en la dirección tcp://%s", n.Address)
   140  	err = socket.Bind("tcp://" + n.Address)
   141  	if err != nil {
   142  		// Si ocurre un error al enlazar el socket, loguea el error y retorna un mensaje de error.
   143  		n.Logger.Printf("Error al enlazar el socket en %s: %v", n.Address, err)
   144  		return errors.New("error al enlazar el socket en " + n.Address)
   145  	}
   146  	n.Logger.Printf("Socket enlazado exitosamente en %s", n.Address)
   147  
   148  	// Inicia una nueva goroutine para escuchar de manera concurrente sin bloquear el hilo principal.
   149  	n.Logger.Printf("Iniciando goroutine para escuchar en el nodo %s", n.Name)
   150  	go func() {
   151  		// Logea que el nodo ha comenzado a escuchar en la dirección configurada.
   152  		n.Logger.Printf("Nodo %s escuchando en %s", n.Name, n.Address)
   153  
   154  		// Entra en un bucle infinito para recibir y procesar mensajes.
   155  		for {
   156  			// Recibe un mensaje del socket.
   157  			n.Logger.Printf("Esperando mensaje en %s...", n.Name)
   158  			message, err := socket.Recv(0)
   159  			if err != nil {
   160  				// Si ocurre un error al recibir el mensaje, loguea el error y termina el bucle.
   161  				n.Logger.Printf("Error al recibir mensaje: %v", err)
   162  				break
   163  			}
   164  			n.Logger.Printf("Mensaje recibido en %s: %v", n.Name, message)
   165  
   166  			// Llama al método HandleProcess, que es implementado por el tipo real de nodo (Follower, Leader, etc.).
   167  			// Este método procesará el mensaje recibido y generará una respuesta.
   168  			n.Logger.Printf("Procesando mensaje en %s...", n.Name)
   169  			response, err := n.Handler.HandleProcess(message)
   170  			if err != nil {
   171  				// Si hay un error al procesar el mensaje, loguea el error y termina el bucle.
   172  				n.Logger.Printf("Error en HandleProcess en %s: %v", n.Name, err)
   173  				break
   174  			}
   175  
   176  			// Envía la respuesta de vuelta al cliente a través del socket.
   177  			n.Logger.Printf("Enviando respuesta en %s: %v", n.Name, response)
   178  			_, err = socket.Send(response, 0)
   179  			if err != nil {
   180  				// Si ocurre un error al enviar la respuesta, loguea el error y termina el bucle.
   181  				n.Logger.Printf("Error al enviar respuesta en %s: %v", n.Name, err)
   182  				break
   183  			}
   184  		}
   185  	}()
   186  
   187  	// La función regresa nil si todo se configura correctamente y la goroutine se inicia sin errores.
   188  	n.Logger.Printf("Escucha iniciada exitosamente en el nodo %s", n.Name)
   189  	return nil
   190  }
   191  
   192  // Close cierra los recursos del nodo.
   193  func (n *AbstractNode) Close() error {
   194  	if n.Socket != nil {
   195  		n.Socket.Close()
   196  		n.Logger.Printf("Socket cerrado para el nodo %s", n.Name)
   197  	}
   198  	if n.Context != nil {
   199  		n.Context.Term()
   200  		n.Logger.Printf("Contexto cerrado para el nodo %s", n.Name)
   201  	}
   202  	return nil
   203  }
   204  
   205  // handleProcess debe ser sobrescrito por las subclases para procesar mensajes.
   206  func (n *AbstractNode) handleProcess(message string) string {
   207  	n.Logger.Printf("Procesando mensaje: %s", message)
   208  	return `{"status":"unhandled"}`
   209  }
   210  

View as plain text

Package builtin

Constants

true and false are the two untyped boolean values.

const (
    true  = 0 == 0 // Untyped bool.
    false = 0 != 0 // Untyped bool.
)

iota is a predeclared identifier representing the untyped integer ordinal number of the current const specification in a (usually parenthesized) const declaration. It is zero-indexed.

const iota = 0 // Untyped int.

Variables

nil is a predeclared identifier representing the zero value for a pointer, channel, func, interface, map, or slice type.

var nil Type // Type must be a pointer, channel, func, interface, map, or slice type

func append ¶

func append(slice []Type, elems ...Type) []Type

The append built-in function appends elements to the end of a slice. If it has sufficient capacity, the destination is resliced to accommodate the new elements. If it does not, a new underlying array will be allocated. Append returns the updated slice. It is therefore necessary to store the result of append, often in the variable holding the slice itself:

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

As a special case, it is legal to append a string to a byte slice, like this:

slice = append([]byte("hello "), "world"...)

func cap ¶

func cap(v Type) int

The cap built-in function returns the capacity of v, according to its type:

Array: the number of elements in v (same as len(v)).
Pointer to array: the number of elements in *v (same as len(v)).
Slice: the maximum length the slice can reach when resliced;
if v is nil, cap(v) is zero.
Channel: the channel buffer capacity, in units of elements;
if v is nil, cap(v) is zero.

For some arguments, such as a simple array expression, the result can be a constant. See the Go language specification's "Length and capacity" section for details.

func clear ¶

func clear[T ~[]Type | ~map[Type]Type1](t T)

The clear built-in function clears maps and slices. For maps, clear deletes all entries, resulting in an empty map. For slices, clear sets all elements up to the length of the slice to the zero value of the respective element type. If the argument type is a type parameter, the type parameter's type set must contain only map or slice types, and clear performs the operation implied by the type argument.

func close ¶

func close(c chan<- Type)

The close built-in function closes a channel, which must be either bidirectional or send-only. It should be executed only by the sender, never the receiver, and has the effect of shutting down the channel after the last sent value is received. After the last value has been received from a closed channel c, any receive from c will succeed without blocking, returning the zero value for the channel element. The form

x, ok := <-c

will also set ok to false for a closed and empty channel.

func complex ¶

func complex(r, i FloatType) ComplexType

The complex built-in function constructs a complex value from two floating-point values. The real and imaginary parts must be of the same size, either float32 or float64 (or assignable to them), and the return value will be the corresponding complex type (complex64 for float32, complex128 for float64).

func copy ¶

func copy(dst, src []Type) int

The copy built-in function copies elements from a source slice into a destination slice. (As a special case, it also will copy bytes from a string to a slice of bytes.) The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

func delete ¶

func delete(m map[Type]Type1, key Type)

The delete built-in function deletes the element with the specified key (m[key]) from the map. If m is nil or there is no such element, delete is a no-op.

func imag ¶

func imag(c ComplexType) FloatType

The imag built-in function returns the imaginary part of the complex number c. The return value will be floating point type corresponding to the type of c.

func len ¶

func len(v Type) int

The len built-in function returns the length of v, according to its type:

Array: the number of elements in v.
Pointer to array: the number of elements in *v (even if v is nil).
Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
String: the number of bytes in v.
Channel: the number of elements queued (unread) in the channel buffer;
         if v is nil, len(v) is zero.

For some arguments, such as a string literal or a simple array expression, the result can be a constant. See the Go language specification's "Length and capacity" section for details.

func make ¶

func make(t Type, size ...IntegerType) Type

The make built-in function allocates and initializes an object of type slice, map, or chan (only). Like new, the first argument is a type, not a value. Unlike new, make's return type is the same as the type of its argument, not a pointer to it. The specification of the result depends on the type:

Slice: The size specifies the length. The capacity of the slice is
equal to its length. A second integer argument may be provided to
specify a different capacity; it must be no smaller than the
length. For example, make([]int, 0, 10) allocates an underlying array
of size 10 and returns a slice of length 0 and capacity 10 that is
backed by this underlying array.
Map: An empty map is allocated with enough space to hold the
specified number of elements. The size may be omitted, in which case
a small starting size is allocated.
Channel: The channel's buffer is initialized with the specified
buffer capacity. If zero, or the size is omitted, the channel is
unbuffered.

func max ¶

func max[T cmp.Ordered](x T, y ...T) T

The max built-in function returns the largest value of a fixed number of arguments of cmp.Ordered types. There must be at least one argument. If T is a floating-point type and any of the arguments are NaNs, max will return NaN.

func min ¶

func min[T cmp.Ordered](x T, y ...T) T

The min built-in function returns the smallest value of a fixed number of arguments of cmp.Ordered types. There must be at least one argument. If T is a floating-point type and any of the arguments are NaNs, min will return NaN.

func new ¶

func new(Type) *Type

The new built-in function allocates memory. The first argument is a type, not a value, and the value returned is a pointer to a newly allocated zero value of that type.

func panic ¶

func panic(v any)

The panic built-in function stops normal execution of the current goroutine. When a function F calls panic, normal execution of F stops immediately. Any functions whose execution was deferred by F are run in the usual way, and then F returns to its caller. To the caller G, the invocation of F then behaves like a call to panic, terminating G's execution and running any deferred functions. This continues until all functions in the executing goroutine have stopped, in reverse order. At that point, the program is terminated with a non-zero exit code. This termination sequence is called panicking and can be controlled by the built-in function recover.

Starting in Go 1.21, calling panic with a nil interface value or an untyped nil causes a run-time error (a different panic). The GODEBUG setting panicnil=1 disables the run-time error.

func print ¶

func print(args ...Type)

The print built-in function formats its arguments in an implementation-specific way and writes the result to standard error. Print is useful for bootstrapping and debugging; it is not guaranteed to stay in the language.

func println ¶

func println(args ...Type)

The println built-in function formats its arguments in an implementation-specific way and writes the result to standard error. Spaces are always added between arguments and a newline is appended. Println is useful for bootstrapping and debugging; it is not guaranteed to stay in the language.

func real ¶

func real(c ComplexType) FloatType

The real built-in function returns the real part of the complex number c. The return value will be floating point type corresponding to the type of c.

func recover ¶

func recover() any

The recover built-in function allows a program to manage behavior of a panicking goroutine. Executing a call to recover inside a deferred function (but not any function called by it) stops the panicking sequence by restoring normal execution and retrieves the error value passed to the call of panic. If recover is called outside the deferred function it will not stop a panicking sequence. In this case, or when the goroutine is not panicking, recover returns nil.

Prior to Go 1.21, recover would also return nil if panic is called with a nil argument. See [panic] for details.

type ComplexType ¶

ComplexType is here for the purposes of documentation only. It is a stand-in for either complex type: complex64 or complex128.

type ComplexType complex64

type FloatType ¶

FloatType is here for the purposes of documentation only. It is a stand-in for either float type: float32 or float64.

type FloatType float32

type IntegerType ¶

IntegerType is here for the purposes of documentation only. It is a stand-in for any integer type: int, uint, int8 etc.

type IntegerType int

type Type ¶

Type is here for the purposes of documentation only. It is a stand-in for any Go type, but represents the same type for any given function invocation.

type Type int

type Type1 ¶

Type1 is here for the purposes of documentation only. It is a stand-in for any Go type, but represents the same type for any given function invocation.

type Type1 int

type any ¶

any is an alias for interface{} and is equivalent to interface{} in all ways.

type any = interface{}

type bool ¶

bool is the set of boolean values, true and false.

type bool bool

type byte ¶

byte is an alias for uint8 and is equivalent to uint8 in all ways. It is used, by convention, to distinguish byte values from 8-bit unsigned integer values.

type byte = uint8

type comparable ¶

comparable is an interface that is implemented by all comparable types (booleans, numbers, strings, pointers, channels, arrays of comparable types, structs whose fields are all comparable types). The comparable interface may only be used as a type parameter constraint, not as the type of a variable.

type comparable interface{ comparable }

type complex128 ¶

complex128 is the set of all complex numbers with float64 real and imaginary parts.

type complex128 complex128

type complex64 ¶

complex64 is the set of all complex numbers with float32 real and imaginary parts.

type complex64 complex64

type error ¶

The error built-in interface type is the conventional interface for representing an error condition, with the nil value representing no error.

type error interface {
    Error() string
}

type float32 ¶

float32 is the set of all IEEE-754 32-bit floating-point numbers.

type float32 float32

type float64 ¶

float64 is the set of all IEEE-754 64-bit floating-point numbers.

type float64 float64

type int ¶

int is a signed integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for, say, int32.

type int int

type int16 ¶

int16 is the set of all signed 16-bit integers. Range: -32768 through 32767.

type int16 int16

type int32 ¶

int32 is the set of all signed 32-bit integers. Range: -2147483648 through 2147483647.

type int32 int32

type int64 ¶

int64 is the set of all signed 64-bit integers. Range: -9223372036854775808 through 9223372036854775807.

type int64 int64

type int8 ¶

int8 is the set of all signed 8-bit integers. Range: -128 through 127.

type int8 int8

type rune ¶

rune is an alias for int32 and is equivalent to int32 in all ways. It is used, by convention, to distinguish character values from integer values.

type rune = int32

type string ¶

string is the set of all strings of 8-bit bytes, conventionally but not necessarily representing UTF-8-encoded text. A string may be empty, but not nil. Values of string type are immutable.

type string string

type uint ¶

uint is an unsigned integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for, say, uint32.

type uint uint

type uint16 ¶

uint16 is the set of all unsigned 16-bit integers. Range: 0 through 65535.

type uint16 uint16

type uint32 ¶

uint32 is the set of all unsigned 32-bit integers. Range: 0 through 4294967295.

type uint32 uint32

type uint64 ¶

uint64 is the set of all unsigned 64-bit integers. Range: 0 through 18446744073709551615.

type uint64 uint64

type uint8 ¶

uint8 is the set of all unsigned 8-bit integers. Range: 0 through 255.

type uint8 uint8

type uintptr ¶

uintptr is an integer type that is large enough to hold the bit pattern of any pointer.

type uintptr uintptr

Package time

start := time.Now()
... operation that takes 20 milliseconds ...
t := time.Now()
elapsed := t.Sub(start)

Constants

These are predefined layouts for use in Time.Format and time.Parse. The reference time used in these layouts is the specific time stamp:

01/02 03:04:05PM '06 -0700

(January 2, 15:04:05, 2006, in time zone seven hours west of GMT). That value is recorded as the constant named Layout, listed below. As a Unix time, this is 1136239445. Since MST is GMT-0700, the reference would be printed by the Unix date command as:

Mon Jan 2 15:04:05 MST 2006

It is a regrettable historic error that the date uses the American convention of putting the numerical month before the day.

The example for Time.Format demonstrates the working of the layout string in detail and is a good reference.

Note that the RFC822, RFC850, and RFC1123 formats should be applied only to local times. Applying them to UTC times will use "UTC" as the time zone abbreviation, while strictly speaking those RFCs require the use of "GMT" in that case. In general RFC1123Z should be used instead of RFC1123 for servers that insist on that format, and RFC3339 should be preferred for new protocols. RFC3339, RFC822, RFC822Z, RFC1123, and RFC1123Z are useful for formatting; when used with time.Parse they do not accept all the time formats permitted by the RFCs and they do accept time formats not formally defined. The RFC3339Nano format removes trailing zeros from the seconds field and thus may not sort correctly once formatted.

Most programs can use one of the defined constants as the layout passed to Format or Parse. The rest of this comment can be ignored unless you are creating a custom layout string.

To define your own format, write down what the reference time would look like formatted your way; see the values of constants like ANSIC, StampMicro or Kitchen for examples. The model is to demonstrate what the reference time looks like so that the Format and Parse methods can apply the same transformation to a general time value.

Here is a summary of the components of a layout string. Each element shows by example the formatting of an element of the reference time. Only these values are recognized. Text in the layout string that is not recognized as part of the reference time is echoed verbatim during Format and expected to appear verbatim in the input to Parse.

Year: "2006" "06"
Month: "Jan" "January" "01" "1"
Day of the week: "Mon" "Monday"
Day of the month: "2" "_2" "02"
Day of the year: "__2" "002"
Hour: "15" "3" "03" (PM or AM)
Minute: "4" "04"
Second: "5" "05"
AM/PM mark: "PM"

Numeric time zone offsets format as follows:

"-0700"     ±hhmm
"-07:00"    ±hh:mm
"-07"       ±hh
"-070000"   ±hhmmss
"-07:00:00" ±hh:mm:ss

Replacing the sign in the format with a Z triggers the ISO 8601 behavior of printing Z instead of an offset for the UTC zone. Thus:

"Z0700"      Z or ±hhmm
"Z07:00"     Z or ±hh:mm
"Z07"        Z or ±hh
"Z070000"    Z or ±hhmmss
"Z07:00:00"  Z or ±hh:mm:ss

Within the format string, the underscores in "_2" and "__2" represent spaces that may be replaced by digits if the following number has multiple digits, for compatibility with fixed-width Unix time formats. A leading zero represents a zero-padded value.

The formats __2 and 002 are space-padded and zero-padded three-character day of year; there is no unpadded day of year format.

A comma or decimal point followed by one or more zeros represents a fractional second, printed to the given number of decimal places. A comma or decimal point followed by one or more nines represents a fractional second, printed to the given number of decimal places, with trailing zeros removed. For example "15:04:05,000" or "15:04:05.000" formats or parses with millisecond precision.

Some valid layouts are invalid time values for time.Parse, due to formats such as _ for space padding and Z for zone information.

const (
    Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    // Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
    DateTime   = "2006-01-02 15:04:05"
    DateOnly   = "2006-01-02"
    TimeOnly   = "15:04:05"
)

Common durations. There is no definition for units of Day or larger to avoid confusion across daylight savings time zone transitions.

To count the number of units in a Duration, divide:

second := time.Second
fmt.Print(int64(second/time.Millisecond)) // prints 1000

To convert an integer number of units to a Duration, multiply:

seconds := 10
fmt.Print(time.Duration(seconds)*time.Second) // prints 10s

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

func After ¶

func After(d Duration) <-chan Time

After waits for the duration to elapse and then sends the current time on the returned channel. It is equivalent to NewTimer(d).C. The underlying Timer is not recovered by the garbage collector until the timer fires. If efficiency is a concern, use NewTimer instead and call Timer.Stop if the timer is no longer needed.

select {
case m := <-c:
    handle(m)
case <-time.After(10 * time.Second):
    fmt.Println("timed out")
}

func Sleep ¶

func Sleep(d Duration)

Sleep pauses the current goroutine for at least the duration d. A negative or zero duration causes Sleep to return immediately.

time.Sleep(100 * time.Millisecond)

func Tick ¶

func Tick(d Duration) <-chan Time

Tick is a convenience wrapper for NewTicker providing access to the ticking channel only. While Tick is useful for clients that have no need to shut down the Ticker, be aware that without a way to shut it down the underlying Ticker cannot be recovered by the garbage collector; it "leaks". Unlike NewTicker, Tick will return nil if d <= 0.

c := time.Tick(5 * time.Second)
for next := range c {
    fmt.Printf("%v %s\n", next, statusUpdate())
}

type Duration ¶

A Duration represents the elapsed time between two instants as an int64 nanosecond count. The representation limits the largest representable duration to approximately 290 years.

type Duration int64

t0 := time.Now()
expensiveCall()
t1 := time.Now()
fmt.Printf("The call took %v to run.\n", t1.Sub(t0))

func ParseDuration ¶

func ParseDuration(s string) (Duration, error)

ParseDuration parses a duration string. A duration string is a possibly signed sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".

hours, _ := time.ParseDuration("10h")
complex, _ := time.ParseDuration("1h10m10s")
micro, _ := time.ParseDuration("1µs")
// The package also accepts the incorrect but common prefix u for micro.
micro2, _ := time.ParseDuration("1us")

fmt.Println(hours)
fmt.Println(complex)
fmt.Printf("There are %.0f seconds in %v.\n", complex.Seconds(), complex)
fmt.Printf("There are %d nanoseconds in %v.\n", micro.Nanoseconds(), micro)
fmt.Printf("There are %6.2e seconds in %v.\n", micro2.Seconds(), micro)

10h0m0s
1h10m10s
There are 4210 seconds in 1h10m10s.
There are 1000 nanoseconds in 1µs.
There are 1.00e-06 seconds in 1µs.

func Since ¶

func Since(t Time) Duration

Since returns the time elapsed since t. It is shorthand for time.Now().Sub(t).

func Until ¶

func Until(t Time) Duration

Until returns the duration until t. It is shorthand for t.Sub(time.Now()).

func (Duration) Abs ¶

func (d Duration) Abs() Duration

Abs returns the absolute value of d. As a special case, math.MinInt64 is converted to math.MaxInt64.

func (Duration) Hours ¶

func (d Duration) Hours() float64

Hours returns the duration as a floating point number of hours.

h, _ := time.ParseDuration("4h30m")
fmt.Printf("I've got %.1f hours of work left.", h.Hours())

I've got 4.5 hours of work left.

func (Duration) Microseconds ¶

func (d Duration) Microseconds() int64

Microseconds returns the duration as an integer microsecond count.

u, _ := time.ParseDuration("1s")
fmt.Printf("One second is %d microseconds.\n", u.Microseconds())

One second is 1000000 microseconds.

func (Duration) Milliseconds ¶

func (d Duration) Milliseconds() int64

Milliseconds returns the duration as an integer millisecond count.

u, _ := time.ParseDuration("1s")
fmt.Printf("One second is %d milliseconds.\n", u.Milliseconds())

One second is 1000 milliseconds.

func (Duration) Minutes ¶

func (d Duration) Minutes() float64

Minutes returns the duration as a floating point number of minutes.

m, _ := time.ParseDuration("1h30m")
fmt.Printf("The movie is %.0f minutes long.", m.Minutes())

The movie is 90 minutes long.

func (Duration) Nanoseconds ¶

func (d Duration) Nanoseconds() int64

Nanoseconds returns the duration as an integer nanosecond count.

u, _ := time.ParseDuration("1µs")
fmt.Printf("One microsecond is %d nanoseconds.\n", u.Nanoseconds())

One microsecond is 1000 nanoseconds.

func (Duration) Round ¶

func (d Duration) Round(m Duration) Duration

Round returns the result of rounding d to the nearest multiple of m. The rounding behavior for halfway values is to round away from zero. If the result exceeds the maximum (or minimum) value that can be stored in a Duration, Round returns the maximum (or minimum) duration. If m <= 0, Round returns d unchanged.

d, err := time.ParseDuration("1h15m30.918273645s")
if err != nil {
    panic(err)
}

round := []time.Duration{
    time.Nanosecond,
    time.Microsecond,
    time.Millisecond,
    time.Second,
    2 * time.Second,
    time.Minute,
    10 * time.Minute,
    time.Hour,
}

for _, r := range round {
    fmt.Printf("d.Round(%6s) = %s\n", r, d.Round(r).String())
}

d.Round(   1ns) = 1h15m30.918273645s
d.Round(   1µs) = 1h15m30.918274s
d.Round(   1ms) = 1h15m30.918s
d.Round(    1s) = 1h15m31s
d.Round(    2s) = 1h15m30s
d.Round(  1m0s) = 1h16m0s
d.Round( 10m0s) = 1h20m0s
d.Round(1h0m0s) = 1h0m0s

func (Duration) Seconds ¶

func (d Duration) Seconds() float64

Seconds returns the duration as a floating point number of seconds.

m, _ := time.ParseDuration("1m30s")
fmt.Printf("Take off in t-%.0f seconds.", m.Seconds())

Take off in t-90 seconds.

func (Duration) String ¶

func (d Duration) String() string

String returns a string representing the duration in the form "72h3m0.5s". Leading zero units are omitted. As a special case, durations less than one second format use a smaller unit (milli-, micro-, or nanoseconds) to ensure that the leading digit is non-zero. The zero duration formats as 0s.

fmt.Println(1*time.Hour + 2*time.Minute + 300*time.Millisecond)
fmt.Println(300 * time.Millisecond)

1h2m0.3s
300ms

func (Duration) Truncate ¶

func (d Duration) Truncate(m Duration) Duration

Truncate returns the result of rounding d toward zero to a multiple of m. If m <= 0, Truncate returns d unchanged.

d, err := time.ParseDuration("1h15m30.918273645s")
if err != nil {
    panic(err)
}

trunc := []time.Duration{
    time.Nanosecond,
    time.Microsecond,
    time.Millisecond,
    time.Second,
    2 * time.Second,
    time.Minute,
    10 * time.Minute,
    time.Hour,
}

for _, t := range trunc {
    fmt.Printf("d.Truncate(%6s) = %s\n", t, d.Truncate(t).String())
}

d.Truncate(   1ns) = 1h15m30.918273645s
d.Truncate(   1µs) = 1h15m30.918273s
d.Truncate(   1ms) = 1h15m30.918s
d.Truncate(    1s) = 1h15m30s
d.Truncate(    2s) = 1h15m30s
d.Truncate(  1m0s) = 1h15m0s
d.Truncate( 10m0s) = 1h10m0s
d.Truncate(1h0m0s) = 1h0m0s

type Location ¶

A Location maps time instants to the zone in use at that time. Typically, the Location represents the collection of time offsets in use in a geographical area. For many Locations the time offset varies depending on whether daylight savings time is in use at the time instant.

Location is used to provide a time zone in a printed Time value and for calculations involving intervals that may cross daylight savings time boundaries.

type Location struct {
    // contains filtered or unexported fields
}

Local represents the system's local time zone. On Unix systems, Local consults the TZ environment variable to find the time zone to use. No TZ means use the system default /etc/localtime. TZ="" means use UTC. TZ="foo" means use file foo in the system timezone directory.

var Local *Location = &localLoc

UTC represents Universal Coordinated Time (UTC).

var UTC *Location = &utcLoc

// China doesn't have daylight saving. It uses a fixed 8 hour offset from UTC.
secondsEastOfUTC := int((8 * time.Hour).Seconds())
beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

// If the system has a timezone database present, it's possible to load a location
// from that, e.g.:
//    newYork, err := time.LoadLocation("America/New_York")

// Creating a time requires a location. Common locations are time.Local and time.UTC.
timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)

// Although the UTC clock time is 1200 and the Beijing clock time is 2000, Beijing is
// 8 hours ahead so the two dates actually represent the same instant.
timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
fmt.Println(timesAreEqual)

true

func FixedZone ¶

func FixedZone(name string, offset int) *Location

FixedZone returns a Location that always uses the given zone name and offset (seconds east of UTC).

loc := time.FixedZone("UTC-8", -8*60*60)
t := time.Date(2009, time.November, 10, 23, 0, 0, 0, loc)
fmt.Println("The time is:", t.Format(time.RFC822))

The time is: 10 Nov 09 23:00 UTC-8

func LoadLocation ¶

func LoadLocation(name string) (*Location, error)

LoadLocation returns the Location with the given name.

If the name is "" or "UTC", LoadLocation returns UTC. If the name is "Local", LoadLocation returns Local.

Otherwise, the name is taken to be a location name corresponding to a file in the IANA Time Zone database, such as "America/New_York".

LoadLocation looks for the IANA Time Zone database in the following locations in order:

• the directory or uncompressed zip file named by the ZONEINFO environment variable
• on a Unix system, the system standard installation location
• $GOROOT/lib/time/zoneinfo.zip
• the time/tzdata package, if it was imported

location, err := time.LoadLocation("America/Los_Angeles")
if err != nil {
    panic(err)
}

timeInUTC := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC)
fmt.Println(timeInUTC.In(location))

2018-08-30 05:00:00 -0700 PDT

func LoadLocationFromTZData ¶

func LoadLocationFromTZData(name string, data []byte) (*Location, error)

LoadLocationFromTZData returns a Location with the given name initialized from the IANA Time Zone database-formatted data. The data should be in the format of a standard IANA time zone file (for example, the content of /etc/localtime on Unix systems).

func (*Location) String ¶

func (l *Location) String() string

String returns a descriptive name for the time zone information, corresponding to the name argument to LoadLocation or FixedZone.

type Month ¶

A Month specifies a month of the year (January = 1, ...).

type Month int

const (
    January Month = 1 + iota
    February
    March
    April
    May
    June
    July
    August
    September
    October
    November
    December
)

_, month, day := time.Now().Date()
if month == time.November && day == 10 {
    fmt.Println("Happy Go day!")
}

func (Month) String ¶

func (m Month) String() string

String returns the English name of the month ("January", "February", ...).

type ParseError ¶

ParseError describes a problem parsing a time string.

type ParseError struct {
    Layout     string
    Value      string
    LayoutElem string
    ValueElem  string
    Message    string
}

func (*ParseError) Error ¶

func (e *ParseError) Error() string

Error returns the string representation of a ParseError.

type Ticker ¶

A Ticker holds a channel that delivers “ticks” of a clock at intervals.

type Ticker struct {
    C <-chan Time // The channel on which the ticks are delivered.
    // contains filtered or unexported fields
}

func NewTicker ¶

func NewTicker(d Duration) *Ticker

NewTicker returns a new Ticker containing a channel that will send the current time on the channel after each tick. The period of the ticks is specified by the duration argument. The ticker will adjust the time interval or drop ticks to make up for slow receivers. The duration d must be greater than zero; if not, NewTicker will panic. Stop the ticker to release associated resources.

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
done := make(chan bool)
go func() {
    time.Sleep(10 * time.Second)
    done <- true
}()
for {
    select {
    case <-done:
        fmt.Println("Done!")
        return
    case t := <-ticker.C:
        fmt.Println("Current time: ", t)
    }
}

func (*Ticker) Reset ¶

func (t *Ticker) Reset(d Duration)

Reset stops a ticker and resets its period to the specified duration. The next tick will arrive after the new period elapses. The duration d must be greater than zero; if not, Reset will panic.

func (*Ticker) Stop ¶

func (t *Ticker) Stop()

Stop turns off a ticker. After Stop, no more ticks will be sent. Stop does not close the channel, to prevent a concurrent goroutine reading from the channel from seeing an erroneous "tick".

type Time ¶

A Time represents an instant in time with nanosecond precision.

Programs using times should typically store and pass them as values, not pointers. That is, time variables and struct fields should be of type time.Time, not *time.Time.

A Time value can be used by multiple goroutines simultaneously except that the methods GobDecode, UnmarshalBinary, UnmarshalJSON and UnmarshalText are not concurrency-safe.

Time instants can be compared using the Before, After, and Equal methods. The Sub method subtracts two instants, producing a Duration. The Add method adds a Time and a Duration, producing a Time.

The zero value of type Time is January 1, year 1, 00:00:00.000000000 UTC. As this time is unlikely to come up in practice, the IsZero method gives a simple way of detecting a time that has not been initialized explicitly.

Each time has an associated Location. The methods Local, UTC, and In return a Time with a specific Location. Changing the Location of a Time value with these methods does not change the actual instant it represents, only the time zone in which to interpret it.

Representations of a Time value saved by the GobEncode, MarshalBinary, MarshalJSON, and MarshalText methods store the Time.Location's offset, but not the location name. They therefore lose information about Daylight Saving Time.

In addition to the required “wall clock” reading, a Time may contain an optional reading of the current process's monotonic clock, to provide additional precision for comparison or subtraction. See the “Monotonic Clocks” section in the package documentation for details.

Note that the Go == operator compares not just the time instant but also the Location and the monotonic clock reading. Therefore, Time values should not be used as map or database keys without first guaranteeing that the identical Location has been set for all values, which can be achieved through use of the UTC or Local method, and that the monotonic clock reading has been stripped by setting t = t.Round(0). In general, prefer t.Equal(u) to t == u, since t.Equal uses the most accurate comparison available and correctly handles the case when only one of its arguments has a monotonic clock reading.

type Time struct {
    // contains filtered or unexported fields
}

func Date ¶

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time

Date returns the Time corresponding to

yyyy-mm-dd hh:mm:ss + nsec nanoseconds

in the appropriate zone for that time in the given location.

The month, day, hour, min, sec, and nsec values may be outside their usual ranges and will be normalized during the conversion. For example, October 32 converts to November 1.

A daylight savings time transition skips or repeats times. For example, in the United States, March 13, 2011 2:15am never occurred, while November 6, 2011 1:15am occurred twice. In such cases, the choice of time zone, and therefore the time, is not well-defined. Date returns a time that is correct in one of the two zones involved in the transition, but it does not guarantee which.

Date panics if loc is nil.

t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
fmt.Printf("Go launched at %s\n", t.Local())

Go launched at 2009-11-10 15:00:00 -0800 PST

func Now ¶

func Now() Time

Now returns the current local time.

func Parse ¶

func Parse(layout, value string) (Time, error)

Parse parses a formatted string and returns the time value it represents. See the documentation for the constant called Layout to see how to represent the format. The second argument must be parseable using the format string (layout) provided as the first argument.

The example for Time.Format demonstrates the working of the layout string in detail and is a good reference.

When parsing (only), the input may contain a fractional second field immediately after the seconds field, even if the layout does not signify its presence. In that case either a comma or a decimal point followed by a maximal series of digits is parsed as a fractional second. Fractional seconds are truncated to nanosecond precision.

Elements omitted from the layout are assumed to be zero or, when zero is impossible, one, so parsing "3:04pm" returns the time corresponding to Jan 1, year 0, 15:04:00 UTC (note that because the year is 0, this time is before the zero Time). Years must be in the range 0000..9999. The day of the week is checked for syntax but it is otherwise ignored.

For layouts specifying the two-digit year 06, a value NN >= 69 will be treated as 19NN and a value NN < 69 will be treated as 20NN.

The remainder of this comment describes the handling of time zones.

In the absence of a time zone indicator, Parse returns a time in UTC.

When parsing a time with a zone offset like -0700, if the offset corresponds to a time zone used by the current location (Local), then Parse uses that location and zone in the returned time. Otherwise it records the time as being in a fabricated location with time fixed at the given zone offset.

When parsing a time with a zone abbreviation like MST, if the zone abbreviation has a defined offset in the current location, then that offset is used. The zone abbreviation "UTC" is recognized as UTC regardless of location. If the zone abbreviation is unknown, Parse records the time as being in a fabricated location with the given zone abbreviation and a zero offset. This choice means that such a time can be parsed and reformatted with the same layout losslessly, but the exact instant used in the representation will differ by the actual zone offset. To avoid such problems, prefer time layouts that use a numeric zone offset, or use ParseInLocation.

// See the example for Time.Format for a thorough description of how
// to define the layout string to parse a time.Time value; Parse and
// Format use the same model to describe their input and output.

// longForm shows by example how the reference time would be represented in
// the desired layout.
const longForm = "Jan 2, 2006 at 3:04pm (MST)"
t, _ := time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)")
fmt.Println(t)

// shortForm is another way the reference time would be represented
// in the desired layout; it has no time zone present.
// Note: without explicit zone, returns time in UTC.
const shortForm = "2006-Jan-02"
t, _ = time.Parse(shortForm, "2013-Feb-03")
fmt.Println(t)

// Some valid layouts are invalid time values, due to format specifiers
// such as _ for space padding and Z for zone information.
// For example the RFC3339 layout 2006-01-02T15:04:05Z07:00
// contains both Z and a time zone offset in order to handle both valid options:
// 2006-01-02T15:04:05Z
// 2006-01-02T15:04:05+07:00
t, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
fmt.Println(t)
t, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05+07:00")
fmt.Println(t)
_, err := time.Parse(time.RFC3339, time.RFC3339)
fmt.Println("error", err) // Returns an error as the layout is not a valid time value

2013-02-03 19:54:00 -0800 PST
2013-02-03 00:00:00 +0000 UTC
2006-01-02 15:04:05 +0000 UTC
2006-01-02 15:04:05 +0700 +0700
error parsing time "2006-01-02T15:04:05Z07:00": extra text: "07:00"

func ParseInLocation ¶

func ParseInLocation(layout, value string, loc *Location) (Time, error)

ParseInLocation is like Parse but differs in two important ways. First, in the absence of time zone information, Parse interprets a time as UTC; ParseInLocation interprets the time as in the given location. Second, when given a zone offset or abbreviation, Parse tries to match it against the Local location; ParseInLocation uses the given location.

loc, _ := time.LoadLocation("Europe/Berlin")

// This will look for the name CEST in the Europe/Berlin time zone.
const longForm = "Jan 2, 2006 at 3:04pm (MST)"
t, _ := time.ParseInLocation(longForm, "Jul 9, 2012 at 5:02am (CEST)", loc)
fmt.Println(t)

// Note: without explicit zone, returns time in given location.
const shortForm = "2006-Jan-02"
t, _ = time.ParseInLocation(shortForm, "2012-Jul-09", loc)
fmt.Println(t)

2012-07-09 05:02:00 +0200 CEST
2012-07-09 00:00:00 +0200 CEST

func Unix ¶

func Unix(sec int64, nsec int64) Time

Unix returns the local Time corresponding to the given Unix time, sec seconds and nsec nanoseconds since January 1, 1970 UTC. It is valid to pass nsec outside the range [0, 999999999]. Not all sec values have a corresponding time value. One such value is 1<<63-1 (the largest int64 value).

unixTime := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
fmt.Println(unixTime.Unix())
t := time.Unix(unixTime.Unix(), 0).UTC()
fmt.Println(t)

1257894000
2009-11-10 23:00:00 +0000 UTC

func UnixMicro ¶

func UnixMicro(usec int64) Time

UnixMicro returns the local Time corresponding to the given Unix time, usec microseconds since January 1, 1970 UTC.

umt := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
fmt.Println(umt.UnixMicro())
t := time.UnixMicro(umt.UnixMicro()).UTC()
fmt.Println(t)

1257894000000000
2009-11-10 23:00:00 +0000 UTC

func UnixMilli ¶

func UnixMilli(msec int64) Time

UnixMilli returns the local Time corresponding to the given Unix time, msec milliseconds since January 1, 1970 UTC.

umt := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
fmt.Println(umt.UnixMilli())
t := time.UnixMilli(umt.UnixMilli()).UTC()
fmt.Println(t)

1257894000000
2009-11-10 23:00:00 +0000 UTC

func (Time) Add ¶

func (t Time) Add(d Duration) Time

Add returns the time t+d.

start := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
afterTenSeconds := start.Add(time.Second * 10)
afterTenMinutes := start.Add(time.Minute * 10)
afterTenHours := start.Add(time.Hour * 10)
afterTenDays := start.Add(time.Hour * 24 * 10)

fmt.Printf("start = %v\n", start)
fmt.Printf("start.Add(time.Second * 10) = %v\n", afterTenSeconds)
fmt.Printf("start.Add(time.Minute * 10) = %v\n", afterTenMinutes)
fmt.Printf("start.Add(time.Hour * 10) = %v\n", afterTenHours)
fmt.Printf("start.Add(time.Hour * 24 * 10) = %v\n", afterTenDays)

start = 2009-01-01 12:00:00 +0000 UTC
start.Add(time.Second * 10) = 2009-01-01 12:00:10 +0000 UTC
start.Add(time.Minute * 10) = 2009-01-01 12:10:00 +0000 UTC
start.Add(time.Hour * 10) = 2009-01-01 22:00:00 +0000 UTC
start.Add(time.Hour * 24 * 10) = 2009-01-11 12:00:00 +0000 UTC

func (Time) AddDate ¶

func (t Time) AddDate(years int, months int, days int) Time

AddDate returns the time corresponding to adding the given number of years, months, and days to t. For example, AddDate(-1, 2, 3) applied to January 1, 2011 returns March 4, 2010.

Note that dates are fundamentally coupled to timezones, and calendrical periods like days don't have fixed durations. AddDate uses the Location of the Time value to determine these durations. That means that the same AddDate arguments can produce a different shift in absolute time depending on the base Time value and its Location. For example, AddDate(0, 0, 1) applied to 12:00 on March 27 always returns 12:00 on March 28. At some locations and in some years this is a 24 hour shift. In others it's a 23 hour shift due to daylight savings time transitions.

AddDate normalizes its result in the same way that Date does, so, for example, adding one month to October 31 yields December 1, the normalized form for November 31.

start := time.Date(2023, 03, 25, 12, 0, 0, 0, time.UTC)
oneDayLater := start.AddDate(0, 0, 1)
dayDuration := oneDayLater.Sub(start)
oneMonthLater := start.AddDate(0, 1, 0)
oneYearLater := start.AddDate(1, 0, 0)

zurich, err := time.LoadLocation("Europe/Zurich")
if err != nil {
    panic(err)
}
// This was the day before a daylight saving time transition in Zürich.
startZurich := time.Date(2023, 03, 25, 12, 0, 0, 0, zurich)
oneDayLaterZurich := startZurich.AddDate(0, 0, 1)
dayDurationZurich := oneDayLaterZurich.Sub(startZurich)

fmt.Printf("oneDayLater: start.AddDate(0, 0, 1) = %v\n", oneDayLater)
fmt.Printf("oneMonthLater: start.AddDate(0, 1, 0) = %v\n", oneMonthLater)
fmt.Printf("oneYearLater: start.AddDate(1, 0, 0) = %v\n", oneYearLater)
fmt.Printf("oneDayLaterZurich: startZurich.AddDate(0, 0, 1) = %v\n", oneDayLaterZurich)
fmt.Printf("Day duration in UTC: %v | Day duration in Zürich: %v\n", dayDuration, dayDurationZurich)

oneDayLater: start.AddDate(0, 0, 1) = 2023-03-26 12:00:00 +0000 UTC
oneMonthLater: start.AddDate(0, 1, 0) = 2023-04-25 12:00:00 +0000 UTC
oneYearLater: start.AddDate(1, 0, 0) = 2024-03-25 12:00:00 +0000 UTC
oneDayLaterZurich: startZurich.AddDate(0, 0, 1) = 2023-03-26 12:00:00 +0200 CEST
Day duration in UTC: 24h0m0s | Day duration in Zürich: 23h0m0s

func (Time) After ¶

func (t Time) After(u Time) bool

After reports whether the time instant t is after u.

year2000 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
year3000 := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)

isYear3000AfterYear2000 := year3000.After(year2000) // True
isYear2000AfterYear3000 := year2000.After(year3000) // False

fmt.Printf("year3000.After(year2000) = %v\n", isYear3000AfterYear2000)
fmt.Printf("year2000.After(year3000) = %v\n", isYear2000AfterYear3000)

year3000.After(year2000) = true
year2000.After(year3000) = false

func (Time) AppendFormat ¶

func (t Time) AppendFormat(b []byte, layout string) []byte

AppendFormat is like Format but appends the textual representation to b and returns the extended buffer.

t := time.Date(2017, time.November, 4, 11, 0, 0, 0, time.UTC)
text := []byte("Time: ")

text = t.AppendFormat(text, time.Kitchen)
fmt.Println(string(text))

Time: 11:00AM

func (Time) Before ¶

func (t Time) Before(u Time) bool

Before reports whether the time instant t is before u.

year2000 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
year3000 := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)

isYear2000BeforeYear3000 := year2000.Before(year3000) // True
isYear3000BeforeYear2000 := year3000.Before(year2000) // False

fmt.Printf("year2000.Before(year3000) = %v\n", isYear2000BeforeYear3000)
fmt.Printf("year3000.Before(year2000) = %v\n", isYear3000BeforeYear2000)

year2000.Before(year3000) = true
year3000.Before(year2000) = false

func (Time) Clock ¶

func (t Time) Clock() (hour, min, sec int)

Clock returns the hour, minute, and second within the day specified by t.

func (Time) Compare ¶

func (t Time) Compare(u Time) int

Compare compares the time instant t with u. If t is before u, it returns -1; if t is after u, it returns +1; if they're the same, it returns 0.

func (Time) Date ¶

func (t Time) Date() (year int, month Month, day int)

Date returns the year, month, and day in which t occurs.

d := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
year, month, day := d.Date()

fmt.Printf("year = %v\n", year)
fmt.Printf("month = %v\n", month)
fmt.Printf("day = %v\n", day)

year = 2000
month = February
day = 1

func (Time) Day ¶

func (t Time) Day() int

Day returns the day of the month specified by t.

d := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
day := d.Day()

fmt.Printf("day = %v\n", day)

day = 1

func (Time) Equal ¶

func (t Time) Equal(u Time) bool

Equal reports whether t and u represent the same time instant. Two times can be equal even if they are in different locations. For example, 6:00 +0200 and 4:00 UTC are Equal. See the documentation on the Time type for the pitfalls of using == with Time values; most code should use Equal instead.

secondsEastOfUTC := int((8 * time.Hour).Seconds())
beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

// Unlike the equal operator, Equal is aware that d1 and d2 are the
// same instant but in different time zones.
d1 := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
d2 := time.Date(2000, 2, 1, 20, 30, 0, 0, beijing)

datesEqualUsingEqualOperator := d1 == d2
datesEqualUsingFunction := d1.Equal(d2)

fmt.Printf("datesEqualUsingEqualOperator = %v\n", datesEqualUsingEqualOperator)
fmt.Printf("datesEqualUsingFunction = %v\n", datesEqualUsingFunction)

datesEqualUsingEqualOperator = false
datesEqualUsingFunction = true

func (Time) Format ¶

func (t Time) Format(layout string) string

Format returns a textual representation of the time value formatted according to the layout defined by the argument. See the documentation for the constant called Layout to see how to represent the layout format.

The executable example for Time.Format demonstrates the working of the layout string in detail and is a good reference.

// Parse a time value from a string in the standard Unix format.
t, err := time.Parse(time.UnixDate, "Wed Feb 25 11:06:39 PST 2015")
if err != nil { // Always check errors even if they should not happen.
    panic(err)
}

tz, err := time.LoadLocation("Asia/Shanghai")
if err != nil { // Always check errors even if they should not happen.
    panic(err)
}

// time.Time's Stringer method is useful without any format.
fmt.Println("default format:", t)

// Predefined constants in the package implement common layouts.
fmt.Println("Unix format:", t.Format(time.UnixDate))

// The time zone attached to the time value affects its output.
fmt.Println("Same, in UTC:", t.UTC().Format(time.UnixDate))

fmt.Println("in Shanghai with seconds:", t.In(tz).Format("2006-01-02T15:04:05 -070000"))

fmt.Println("in Shanghai with colon seconds:", t.In(tz).Format("2006-01-02T15:04:05 -07:00:00"))

// The rest of this function demonstrates the properties of the
// layout string used in the format.

// The layout string used by the Parse function and Format method
// shows by example how the reference time should be represented.
// We stress that one must show how the reference time is formatted,
// not a time of the user's choosing. Thus each layout string is a
// representation of the time stamp,
//	Jan 2 15:04:05 2006 MST
// An easy way to remember this value is that it holds, when presented
// in this order, the values (lined up with the elements above):
//	  1 2  3  4  5    6  -7
// There are some wrinkles illustrated below.

// Most uses of Format and Parse use constant layout strings such as
// the ones defined in this package, but the interface is flexible,
// as these examples show.

// Define a helper function to make the examples' output look nice.
do := func(name, layout, want string) {
    got := t.Format(layout)
    if want != got {
        fmt.Printf("error: for %q got %q; expected %q\n", layout, got, want)
        return
    }
    fmt.Printf("%-16s %q gives %q\n", name, layout, got)
}

// Print a header in our output.
fmt.Printf("\nFormats:\n\n")

// Simple starter examples.
do("Basic full date", "Mon Jan 2 15:04:05 MST 2006", "Wed Feb 25 11:06:39 PST 2015")
do("Basic short date", "2006/01/02", "2015/02/25")

// The hour of the reference time is 15, or 3PM. The layout can express
// it either way, and since our value is the morning we should see it as
// an AM time. We show both in one format string. Lower case too.
do("AM/PM", "3PM==3pm==15h", "11AM==11am==11h")

// When parsing, if the seconds value is followed by a decimal point
// and some digits, that is taken as a fraction of a second even if
// the layout string does not represent the fractional second.
// Here we add a fractional second to our time value used above.
t, err = time.Parse(time.UnixDate, "Wed Feb 25 11:06:39.1234 PST 2015")
if err != nil {
    panic(err)
}
// It does not appear in the output if the layout string does not contain
// a representation of the fractional second.
do("No fraction", time.UnixDate, "Wed Feb 25 11:06:39 PST 2015")

// Fractional seconds can be printed by adding a run of 0s or 9s after
// a decimal point in the seconds value in the layout string.
// If the layout digits are 0s, the fractional second is of the specified
// width. Note that the output has a trailing zero.
do("0s for fraction", "15:04:05.00000", "11:06:39.12340")

// If the fraction in the layout is 9s, trailing zeros are dropped.
do("9s for fraction", "15:04:05.99999999", "11:06:39.1234")

default format: 2015-02-25 11:06:39 -0800 PST
Unix format: Wed Feb 25 11:06:39 PST 2015
Same, in UTC: Wed Feb 25 19:06:39 UTC 2015
in Shanghai with seconds: 2015-02-26T03:06:39 +080000
in Shanghai with colon seconds: 2015-02-26T03:06:39 +08:00:00

Formats:

Basic full date  "Mon Jan 2 15:04:05 MST 2006" gives "Wed Feb 25 11:06:39 PST 2015"
Basic short date "2006/01/02" gives "2015/02/25"
AM/PM            "3PM==3pm==15h" gives "11AM==11am==11h"
No fraction      "Mon Jan _2 15:04:05 MST 2006" gives "Wed Feb 25 11:06:39 PST 2015"
0s for fraction  "15:04:05.00000" gives "11:06:39.12340"
9s for fraction  "15:04:05.99999999" gives "11:06:39.1234"

// Parse a time value from a string in the standard Unix format.
t, err := time.Parse(time.UnixDate, "Sat Mar 7 11:06:39 PST 2015")
if err != nil { // Always check errors even if they should not happen.
    panic(err)
}

// Define a helper function to make the examples' output look nice.
do := func(name, layout, want string) {
    got := t.Format(layout)
    if want != got {
        fmt.Printf("error: for %q got %q; expected %q\n", layout, got, want)
        return
    }
    fmt.Printf("%-16s %q gives %q\n", name, layout, got)
}

// The predefined constant Unix uses an underscore to pad the day.
do("Unix", time.UnixDate, "Sat Mar  7 11:06:39 PST 2015")

// For fixed-width printing of values, such as the date, that may be one or
// two characters (7 vs. 07), use an _ instead of a space in the layout string.
// Here we print just the day, which is 2 in our layout string and 7 in our
// value.
do("No pad", "<2>", "<7>")

// An underscore represents a space pad, if the date only has one digit.
do("Spaces", "<_2>", "< 7>")

// A "0" indicates zero padding for single-digit values.
do("Zeros", "<02>", "<07>")

// If the value is already the right width, padding is not used.
// For instance, the second (05 in the reference time) in our value is 39,
// so it doesn't need padding, but the minutes (04, 06) does.
do("Suppressed pad", "04:05", "06:39")

Unix             "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
No pad           "<2>" gives "<7>"
Spaces           "<_2>" gives "< 7>"
Zeros            "<02>" gives "<07>"
Suppressed pad   "04:05" gives "06:39"

func (Time) GoString ¶

func (t Time) GoString() string

GoString implements fmt.GoStringer and formats t to be printed in Go source code.

t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
fmt.Println(t.GoString())
t = t.Add(1 * time.Minute)
fmt.Println(t.GoString())
t = t.AddDate(0, 1, 0)
fmt.Println(t.GoString())
t, _ = time.Parse("Jan 2, 2006 at 3:04pm (MST)", "Feb 3, 2013 at 7:54pm (UTC)")
fmt.Println(t.GoString())

time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
time.Date(2009, time.November, 10, 23, 1, 0, 0, time.UTC)
time.Date(2009, time.December, 10, 23, 1, 0, 0, time.UTC)
time.Date(2013, time.February, 3, 19, 54, 0, 0, time.UTC)

func (*Time) GobDecode ¶

func (t *Time) GobDecode(data []byte) error

GobDecode implements the gob.GobDecoder interface.

func (Time) GobEncode ¶

func (t Time) GobEncode() ([]byte, error)

GobEncode implements the gob.GobEncoder interface.

func (Time) Hour ¶

func (t Time) Hour() int

Hour returns the hour within the day specified by t, in the range [0, 23].

func (Time) ISOWeek ¶

func (t Time) ISOWeek() (year, week int)

ISOWeek returns the ISO 8601 year and week number in which t occurs. Week ranges from 1 to 53. Jan 01 to Jan 03 of year n might belong to week 52 or 53 of year n-1, and Dec 29 to Dec 31 might belong to week 1 of year n+1.

func (Time) In ¶

func (t Time) In(loc *Location) Time

In returns a copy of t representing the same time instant, but with the copy's location information set to loc for display purposes.

In panics if loc is nil.

func (Time) IsDST ¶

func (t Time) IsDST() bool

IsDST reports whether the time in the configured location is in Daylight Savings Time.

func (Time) IsZero ¶

func (t Time) IsZero() bool

IsZero reports whether t represents the zero time instant, January 1, year 1, 00:00:00 UTC.

func (Time) Local ¶

func (t Time) Local() Time

Local returns t with the location set to local time.

func (Time) Location ¶

func (t Time) Location() *Location

Location returns the time zone information associated with t.

func (Time) MarshalBinary ¶

func (t Time) MarshalBinary() ([]byte, error)

MarshalBinary implements the encoding.BinaryMarshaler interface.

func (Time) MarshalJSON ¶

func (t Time) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface. The time is a quoted string in the RFC 3339 format with sub-second precision. If the timestamp cannot be represented as valid RFC 3339 (e.g., the year is out of range), then an error is reported.

func (Time) MarshalText ¶

func (t Time) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface. The time is formatted in RFC 3339 format with sub-second precision. If the timestamp cannot be represented as valid RFC 3339 (e.g., the year is out of range), then an error is reported.

func (Time) Minute ¶

func (t Time) Minute() int

Minute returns the minute offset within the hour specified by t, in the range [0, 59].

func (Time) Month ¶

func (t Time) Month() Month

Month returns the month of the year specified by t.

func (Time) Nanosecond ¶

func (t Time) Nanosecond() int

Nanosecond returns the nanosecond offset within the second specified by t, in the range [0, 999999999].

func (Time) Round ¶

func (t Time) Round(d Duration) Time

Round returns the result of rounding t to the nearest multiple of d (since the zero time). The rounding behavior for halfway values is to round up. If d <= 0, Round returns t stripped of any monotonic clock reading but otherwise unchanged.

Round operates on the time as an absolute duration since the zero time; it does not operate on the presentation form of the time. Thus, Round(Hour) may return a time with a non-zero minute, depending on the time's Location.

t := time.Date(0, 0, 0, 12, 15, 30, 918273645, time.UTC)
round := []time.Duration{
    time.Nanosecond,
    time.Microsecond,
    time.Millisecond,
    time.Second,
    2 * time.Second,
    time.Minute,
    10 * time.Minute,
    time.Hour,
}

for _, d := range round {
    fmt.Printf("t.Round(%6s) = %s\n", d, t.Round(d).Format("15:04:05.999999999"))
}

t.Round(   1ns) = 12:15:30.918273645
t.Round(   1µs) = 12:15:30.918274
t.Round(   1ms) = 12:15:30.918
t.Round(    1s) = 12:15:31
t.Round(    2s) = 12:15:30
t.Round(  1m0s) = 12:16:00
t.Round( 10m0s) = 12:20:00
t.Round(1h0m0s) = 12:00:00

func (Time) Second ¶

func (t Time) Second() int

Second returns the second offset within the minute specified by t, in the range [0, 59].

func (Time) String ¶

func (t Time) String() string

String returns the time formatted using the format string

"2006-01-02 15:04:05.999999999 -0700 MST"

If the time has a monotonic clock reading, the returned string includes a final field "m=±<value>", where value is the monotonic clock reading formatted as a decimal number of seconds.

The returned string is meant for debugging; for a stable serialized representation, use t.MarshalText, t.MarshalBinary, or t.Format with an explicit format string.

timeWithNanoseconds := time.Date(2000, 2, 1, 12, 13, 14, 15, time.UTC)
withNanoseconds := timeWithNanoseconds.String()

timeWithoutNanoseconds := time.Date(2000, 2, 1, 12, 13, 14, 0, time.UTC)
withoutNanoseconds := timeWithoutNanoseconds.String()

fmt.Printf("withNanoseconds = %v\n", string(withNanoseconds))
fmt.Printf("withoutNanoseconds = %v\n", string(withoutNanoseconds))

withNanoseconds = 2000-02-01 12:13:14.000000015 +0000 UTC
withoutNanoseconds = 2000-02-01 12:13:14 +0000 UTC

func (Time) Sub ¶

func (t Time) Sub(u Time) Duration

Sub returns the duration t-u. If the result exceeds the maximum (or minimum) value that can be stored in a Duration, the maximum (or minimum) duration will be returned. To compute t-d for a duration d, use t.Add(-d).

start := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
end := time.Date(2000, 1, 1, 12, 0, 0, 0, time.UTC)

difference := end.Sub(start)
fmt.Printf("difference = %v\n", difference)

difference = 12h0m0s

func (Time) Truncate ¶

func (t Time) Truncate(d Duration) Time

Truncate returns the result of rounding t down to a multiple of d (since the zero time). If d <= 0, Truncate returns t stripped of any monotonic clock reading but otherwise unchanged.

Truncate operates on the time as an absolute duration since the zero time; it does not operate on the presentation form of the time. Thus, Truncate(Hour) may return a time with a non-zero minute, depending on the time's Location.

t, _ := time.Parse("2006 Jan 02 15:04:05", "2012 Dec 07 12:15:30.918273645")
trunc := []time.Duration{
    time.Nanosecond,
    time.Microsecond,
    time.Millisecond,
    time.Second,
    2 * time.Second,
    time.Minute,
    10 * time.Minute,
}

for _, d := range trunc {
    fmt.Printf("t.Truncate(%5s) = %s\n", d, t.Truncate(d).Format("15:04:05.999999999"))
}
// To round to the last midnight in the local timezone, create a new Date.
midnight := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
_ = midnight

t.Truncate(  1ns) = 12:15:30.918273645
t.Truncate(  1µs) = 12:15:30.918273
t.Truncate(  1ms) = 12:15:30.918
t.Truncate(   1s) = 12:15:30
t.Truncate(   2s) = 12:15:30
t.Truncate( 1m0s) = 12:15:00
t.Truncate(10m0s) = 12:10:00

func (Time) UTC ¶

func (t Time) UTC() Time

UTC returns t with the location set to UTC.

func (Time) Unix ¶

func (t Time) Unix() int64

Unix returns t as a Unix time, the number of seconds elapsed since January 1, 1970 UTC. The result does not depend on the location associated with t. Unix-like operating systems often record time as a 32-bit count of seconds, but since the method here returns a 64-bit value it is valid for billions of years into the past or future.

// 1 billion seconds of Unix, three ways.
fmt.Println(time.Unix(1e9, 0).UTC())     // 1e9 seconds
fmt.Println(time.Unix(0, 1e18).UTC())    // 1e18 nanoseconds
fmt.Println(time.Unix(2e9, -1e18).UTC()) // 2e9 seconds - 1e18 nanoseconds

t := time.Date(2001, time.September, 9, 1, 46, 40, 0, time.UTC)
fmt.Println(t.Unix())     // seconds since 1970
fmt.Println(t.UnixNano()) // nanoseconds since 1970

2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
1000000000
1000000000000000000

func (Time) UnixMicro ¶

func (t Time) UnixMicro() int64

UnixMicro returns t as a Unix time, the number of microseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in microseconds cannot be represented by an int64 (a date before year -290307 or after year 294246). The result does not depend on the location associated with t.

func (Time) UnixMilli ¶

func (t Time) UnixMilli() int64

UnixMilli returns t as a Unix time, the number of milliseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in milliseconds cannot be represented by an int64 (a date more than 292 million years before or after 1970). The result does not depend on the location associated with t.

func (Time) UnixNano ¶

func (t Time) UnixNano() int64

UnixNano returns t as a Unix time, the number of nanoseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in nanoseconds cannot be represented by an int64 (a date before the year 1678 or after 2262). Note that this means the result of calling UnixNano on the zero Time is undefined. The result does not depend on the location associated with t.

func (*Time) UnmarshalBinary ¶

func (t *Time) UnmarshalBinary(data []byte) error

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.

func (*Time) UnmarshalJSON ¶

func (t *Time) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface. The time must be a quoted string in the RFC 3339 format.

func (*Time) UnmarshalText ¶

func (t *Time) UnmarshalText(data []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface. The time must be in the RFC 3339 format.

func (Time) Weekday ¶

func (t Time) Weekday() Weekday

Weekday returns the day of the week specified by t.

func (Time) Year ¶

func (t Time) Year() int

Year returns the year in which t occurs.

func (Time) YearDay ¶

func (t Time) YearDay() int

YearDay returns the day of the year specified by t, in the range [1,365] for non-leap years, and [1,366] in leap years.

func (Time) Zone ¶

func (t Time) Zone() (name string, offset int)

Zone computes the time zone in effect at time t, returning the abbreviated name of the zone (such as "CET") and its offset in seconds east of UTC.

func (Time) ZoneBounds ¶

func (t Time) ZoneBounds() (start, end Time)

ZoneBounds returns the bounds of the time zone in effect at time t. The zone begins at start and the next zone begins at end. If the zone begins at the beginning of time, start will be returned as a zero Time. If the zone goes on forever, end will be returned as a zero Time. The Location of the returned times will be the same as t.

type Timer ¶

The Timer type represents a single event. When the Timer expires, the current time will be sent on C, unless the Timer was created by AfterFunc. A Timer must be created with NewTimer or AfterFunc.

type Timer struct {
    C <-chan Time
    // contains filtered or unexported fields
}

func AfterFunc ¶

func AfterFunc(d Duration, f func()) *Timer

AfterFunc waits for the duration to elapse and then calls f in its own goroutine. It returns a Timer that can be used to cancel the call using its Stop method. The returned Timer's C field is not used and will be nil.

func NewTimer ¶

func NewTimer(d Duration) *Timer

NewTimer creates a new Timer that will send the current time on its channel after at least duration d.

func (*Timer) Reset ¶

func (t *Timer) Reset(d Duration) bool

Reset changes the timer to expire after duration d. It returns true if the timer had been active, false if the timer had expired or been stopped.

For a Timer created with NewTimer, Reset should be invoked only on stopped or expired timers with drained channels.

If a program has already received a value from t.C, the timer is known to have expired and the channel drained, so t.Reset can be used directly. If a program has not yet received a value from t.C, however, the timer must be stopped and—if Stop reports that the timer expired before being stopped—the channel explicitly drained:

if !t.Stop() {
	<-t.C
}
t.Reset(d)

This should not be done concurrent to other receives from the Timer's channel.

Note that it is not possible to use Reset's return value correctly, as there is a race condition between draining the channel and the new timer expiring. Reset should always be invoked on stopped or expired channels, as described above. The return value exists to preserve compatibility with existing programs.

For a Timer created with AfterFunc(d, f), Reset either reschedules when f will run, in which case Reset returns true, or schedules f to run again, in which case it returns false. When Reset returns false, Reset neither waits for the prior f to complete before returning nor does it guarantee that the subsequent goroutine running f does not run concurrently with the prior one. If the caller needs to know whether the prior execution of f is completed, it must coordinate with f explicitly.

func (*Timer) Stop ¶

func (t *Timer) Stop() bool

Stop prevents the Timer from firing. It returns true if the call stops the timer, false if the timer has already expired or been stopped. Stop does not close the channel, to prevent a read from the channel succeeding incorrectly.

To ensure the channel is empty after a call to Stop, check the return value and drain the channel. For example, assuming the program has not received from t.C already:

if !t.Stop() {
	<-t.C
}

This cannot be done concurrent to other receives from the Timer's channel or other calls to the Timer's Stop method.

For a timer created with AfterFunc(d, f), if t.Stop returns false, then the timer has already expired and the function f has been started in its own goroutine; Stop does not wait for f to complete before returning. If the caller needs to know whether f is completed, it must coordinate with f explicitly.

type Weekday ¶

A Weekday specifies a day of the week (Sunday = 0, ...).

type Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

func (Weekday) String ¶

func (d Weekday) String() string

String returns the English name of the day ("Sunday", "Monday", ...).

Subdirectories

Package zmq4

GODEBUG=asyncpreemptoff=1

zctx, _ := zmq.NewContext()

ctx, cancel := context.WithCancel(context.Background())

go func() {
    chSignal := make(chan os.Signal, 1)
    signal.Notify(chSignal, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
    <-chSignal
    zmq4.SetRetryAfterEINTR(false)
    zctx.SetRetryAfterEINTR(false)
    cancel()
}()

Constants

const (

    // On Windows platform some of the standard POSIX errnos are not defined.
    EADDRINUSE      = Errno(C.EADDRINUSE)
    EADDRNOTAVAIL   = Errno(C.EADDRNOTAVAIL)
    EAFNOSUPPORT    = Errno(C.EAFNOSUPPORT)
    ECONNABORTED    = Errno(C.ECONNABORTED)
    ECONNREFUSED    = Errno(C.ECONNREFUSED)
    ECONNRESET      = Errno(C.ECONNRESET)
    EHOSTUNREACH    = Errno(C.EHOSTUNREACH)
    EINPROGRESS     = Errno(C.EINPROGRESS)
    EMSGSIZE        = Errno(C.EMSGSIZE)
    ENETDOWN        = Errno(C.ENETDOWN)
    ENETRESET       = Errno(C.ENETRESET)
    ENETUNREACH     = Errno(C.ENETUNREACH)
    ENOBUFS         = Errno(C.ENOBUFS)
    ENOTCONN        = Errno(C.ENOTCONN)
    ENOTSOCK        = Errno(C.ENOTSOCK)
    ENOTSUP         = Errno(C.ENOTSUP)
    EPROTONOSUPPORT = Errno(C.EPROTONOSUPPORT)
    ETIMEDOUT       = Errno(C.ETIMEDOUT)

    // Native 0MQ error codes.
    EFSM           = Errno(C.EFSM)
    EMTHREAD       = Errno(C.EMTHREAD)
    ENOCOMPATPROTO = Errno(C.ENOCOMPATPROTO)
    ETERM          = Errno(C.ETERM)
)

const (
    MaxSocketsDflt = int(C.ZMQ_MAX_SOCKETS_DFLT)
    IoThreadsDflt  = int(C.ZMQ_IO_THREADS_DFLT)
)

const (
    // Constants for NewSocket()
    // See: http://api.zeromq.org/4-1:zmq-socket#toc3
    REQ    = Type(C.ZMQ_REQ)
    REP    = Type(C.ZMQ_REP)
    DEALER = Type(C.ZMQ_DEALER)
    ROUTER = Type(C.ZMQ_ROUTER)
    PUB    = Type(C.ZMQ_PUB)
    SUB    = Type(C.ZMQ_SUB)
    XPUB   = Type(C.ZMQ_XPUB)
    XSUB   = Type(C.ZMQ_XSUB)
    PUSH   = Type(C.ZMQ_PUSH)
    PULL   = Type(C.ZMQ_PULL)
    PAIR   = Type(C.ZMQ_PAIR)
    STREAM = Type(C.ZMQ_STREAM)
)

const (
    // Flags for (*Socket)Send(), (*Socket)Recv()
    // For Send, see: http://api.zeromq.org/4-1:zmq-send#toc2
    // For Recv, see: http://api.zeromq.org/4-1:zmq-msg-recv#toc2
    DONTWAIT = Flag(C.ZMQ_DONTWAIT)
    SNDMORE  = Flag(C.ZMQ_SNDMORE)
)

const (
    // Flags for (*Socket)Monitor() and (*Socket)RecvEvent()
    // See: http://api.zeromq.org/4-3:zmq-socket-monitor#toc3
    EVENT_ALL                        = Event(C.ZMQ_EVENT_ALL)
    EVENT_CONNECTED                  = Event(C.ZMQ_EVENT_CONNECTED)
    EVENT_CONNECT_DELAYED            = Event(C.ZMQ_EVENT_CONNECT_DELAYED)
    EVENT_CONNECT_RETRIED            = Event(C.ZMQ_EVENT_CONNECT_RETRIED)
    EVENT_LISTENING                  = Event(C.ZMQ_EVENT_LISTENING)
    EVENT_BIND_FAILED                = Event(C.ZMQ_EVENT_BIND_FAILED)
    EVENT_ACCEPTED                   = Event(C.ZMQ_EVENT_ACCEPTED)
    EVENT_ACCEPT_FAILED              = Event(C.ZMQ_EVENT_ACCEPT_FAILED)
    EVENT_CLOSED                     = Event(C.ZMQ_EVENT_CLOSED)
    EVENT_CLOSE_FAILED               = Event(C.ZMQ_EVENT_CLOSE_FAILED)
    EVENT_DISCONNECTED               = Event(C.ZMQ_EVENT_DISCONNECTED)
    EVENT_MONITOR_STOPPED            = Event(C.ZMQ_EVENT_MONITOR_STOPPED)
    EVENT_HANDSHAKE_FAILED_NO_DETAIL = Event(C.ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL)
    EVENT_HANDSHAKE_SUCCEEDED        = Event(C.ZMQ_EVENT_HANDSHAKE_SUCCEEDED)
    EVENT_HANDSHAKE_FAILED_PROTOCOL  = Event(C.ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL)
    EVENT_HANDSHAKE_FAILED_AUTH      = Event(C.ZMQ_EVENT_HANDSHAKE_FAILED_AUTH)
)

const (
    // Flags for (*Socket)GetEvents()
    // See: http://api.zeromq.org/4-1:zmq-getsockopt#toc8
    POLLIN  = State(C.ZMQ_POLLIN)
    POLLOUT = State(C.ZMQ_POLLOUT)
)

const (
    // Constants for (*Socket)GetMechanism()
    // See: http://api.zeromq.org/4-1:zmq-getsockopt#toc22
    NULL   = Mechanism(C.ZMQ_NULL)
    PLAIN  = Mechanism(C.ZMQ_PLAIN)
    CURVE  = Mechanism(C.ZMQ_CURVE)
    GSSAPI = Mechanism(C.ZMQ_GSSAPI)
)

const CURVE_ALLOW_ANY = "*"

Variables

var (
    ErrorContextClosed         = errors.New("Context is closed")
    ErrorSocketClosed          = errors.New("Socket is closed")
    ErrorMoreExpected          = errors.New("More expected")
    ErrorNotImplemented405     = errors.New("Not implemented, requires 0MQ version 4.0.5")
    ErrorNotImplemented41      = errors.New("Not implemented, requires 0MQ version 4.1")
    ErrorNotImplemented42      = errors.New("Not implemented, requires 0MQ version 4.2")
    ErrorNotImplementedWindows = errors.New("Not implemented on Windows")
    ErrorNoSocket              = errors.New("No such socket")
)

func AuthAllow ¶

func AuthAllow(domain string, addresses ...string)

Allow (whitelist) some addresses for a domain.

An address can be a single IP address, or an IP address and mask in CIDR notation.

For NULL, all clients from these addresses will be accepted.

For PLAIN and CURVE, they will be allowed to continue with authentication.

You can call this method multiple times to whitelist multiple IP addresses.

If you whitelist a single address for a domain, any non-whitelisted addresses for that domain are treated as blacklisted.

Use domain "*" for all domains.

For backward compatibility: if domain can be parsed as an IP address, it will be interpreted as another address, and it and all remaining addresses will be added to all domains.

func AuthCurveAdd ¶

func AuthCurveAdd(domain string, pubkeys ...string)

Add public user keys for CURVE authentication for a given domain.

To cover all domains, use "*".

Public keys are in Z85 printable text format.

To allow all client keys without checking, specify CURVE_ALLOW_ANY for the key.

func AuthCurvePublic ¶

func AuthCurvePublic(z85SecretKey string) (z85PublicKey string, err error)

Helper function to derive z85 public key from secret key

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func AuthCurveRemove ¶

func AuthCurveRemove(domain string, pubkeys ...string)

Remove user keys from CURVE authentication for a given domain.

func AuthCurveRemoveAll ¶

func AuthCurveRemoveAll(domain string)

Remove all user keys from CURVE authentication for a given domain.

func AuthDeny ¶

func AuthDeny(domain string, addresses ...string)

Deny (blacklist) some addresses for a domain.

An address can be a single IP address, or an IP address and mask in CIDR notation.

For all security mechanisms, this rejects the connection without any further authentication.

Use either a whitelist for a domain, or a blacklist for a domain, not both. If you define both a whitelist and a blacklist for a domain, only the whitelist takes effect.

Use domain "*" for all domains.

For backward compatibility: if domain can be parsed as an IP address, it will be interpreted as another address, and it and all remaining addresses will be added to all domains.

func AuthMetaBlob ¶

func AuthMetaBlob(key, value string) (blob []byte, err error)

This encodes a key/value pair into the format used by a ZAP handler.

Returns an error if key is more then 255 characters long.

func AuthPlainAdd ¶

func AuthPlainAdd(domain, username, password string)

Add a user for PLAIN authentication for a given domain.

Set `domain` to "*" to apply to all domains.

func AuthPlainRemove ¶

func AuthPlainRemove(domain string, usernames ...string)

Remove users from PLAIN authentication for a given domain.

func AuthPlainRemoveAll ¶

func AuthPlainRemoveAll(domain string)

Remove all users from PLAIN authentication for a given domain.

func AuthSetMetadataHandler ¶

func AuthSetMetadataHandler(
    handler func(
        version, request_id, domain, address, identity, mechanism string, credentials ...string) (metadata map[string]string))

This function sets the metadata handler that is called by the ZAP handler to retrieve key/value properties that should be set on reply messages in case of a status code "200" (succes).

Default properties are `Socket-Type`, which is already set, and `Identity` and `User-Id` that are empty by default. The last two can be set, and more properties can be added.

The `User-Id` property is used for the `user id` frame of the reply message. All other properties are stored in the `metadata` frame of the reply message.

The default handler returns an empty map.

For the meaning of the handler arguments, and other details, see: http://rfc.zeromq.org/spec:27#toc10

func AuthSetVerbose ¶

func AuthSetVerbose(verbose bool)

Enable verbose tracing of commands and activity.

func AuthStart ¶

func AuthStart() (err error)

Start authentication.

Note that until you add policies, all incoming NULL connections are allowed (classic ZeroMQ behaviour), and all PLAIN and CURVE connections are denied.

func AuthStop ¶

func AuthStop()

Stop authentication.

func Error ¶

func Error(e int) string

Get 0MQ error message string.

func GetBlocky ¶

func GetBlocky() (bool, error)

Returns the blocky setting in the default context.

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func GetIoThreads ¶

func GetIoThreads() (int, error)

Returns the size of the 0MQ thread pool in the default context.

func GetIpv6 ¶

func GetIpv6() (bool, error)

Returns the IPv6 option in the default context.

func GetMaxMsgsz ¶

func GetMaxMsgsz() (int, error)

Returns the maximum message size in the default context.

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func GetMaxSockets ¶

func GetMaxSockets() (int, error)

Returns the maximum number of sockets allowed in the default context.

func GetRetryAfterEINTR ¶

func GetRetryAfterEINTR() bool

Returns the retry after EINTR setting in the default context.

func HasCurve ¶

func HasCurve() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the CURVE security mechanism

func HasGssapi ¶

func HasGssapi() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the GSSAPI security mechanism

func HasIpc ¶

func HasIpc() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the ipc:// protocol

func HasNorm ¶

func HasNorm() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the norm:// protocol

func HasPgm ¶

func HasPgm() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the pgm:// protocol

func HasTipc ¶

func HasTipc() bool

Returns false for ZeroMQ version < 4.1.0

Else: returns true if the library supports the tipc:// protocol

func NewCurveKeypair ¶

func NewCurveKeypair() (z85_public_key, z85_secret_key string, err error)

Generate a new CURVE keypair

See: http://api.zeromq.org/4-1:zmq-curve-keypair#toc2

func Proxy ¶

func Proxy(frontend, backend, capture *Socket) error

Start built-in ØMQ proxy

See: http://api.zeromq.org/4-1:zmq-proxy#toc2

func ProxySteerable ¶

func ProxySteerable(frontend, backend, capture, control *Socket) error

Start built-in ØMQ proxy with PAUSE/RESUME/TERMINATE control flow

Returns ErrorNotImplemented405 with ZeroMQ version < 4.0.5

See: http://api.zeromq.org/4-1:zmq-proxy-steerable#toc2

func SetBlocky ¶

func SetBlocky(i bool) error

Sets the blocky behavior in the default context.

See: http://api.zeromq.org/4-2:zmq-ctx-set#toc3

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func SetIoThreads ¶

func SetIoThreads(n int) error

Specifies the size of the 0MQ thread pool to handle I/O operations in the default context. If your application is using only the inproc transport for messaging you may set this to zero, otherwise set it to at least one. This option only applies before creating any sockets.

Default value: 1

func SetIpv6 ¶

func SetIpv6(i bool) error

Sets the IPv6 value for all sockets created in the default context from this point onwards. A value of true means IPv6 is enabled, while false means the socket will use only IPv4. When IPv6 is enabled, a socket will connect to, or accept connections from, both IPv4 and IPv6 hosts.

Default value: false

func SetMaxMsgsz ¶

func SetMaxMsgsz(n int) error

Set maximum message size in the default context.

Default value: INT_MAX

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func SetMaxSockets ¶

func SetMaxSockets(n int) error

Sets the maximum number of sockets allowed in the default context.

Default value: 1024

func SetRetryAfterEINTR ¶

func SetRetryAfterEINTR(retry bool)

Sets the retry after EINTR setting in the default context.

Initital value is true.

func SetThreadPriority ¶

func SetThreadPriority(n int) error

Sets scheduling priority for default context’s thread pool.

This option requires ZeroMQ version 4.1, and is not available on Windows.

Supported values for this option depend on chosen scheduling policy. Details can be found in sched.h file, or at http://man7.org/linux/man-pages/man2/sched_setscheduler.2.html

This option only applies before creating any sockets on the context.

Default value: -1

Returns ErrorNotImplemented41 with ZeroMQ version < 4.1

Returns ErrorNotImplementedWindows on Windows

func SetThreadSchedPolicy ¶

func SetThreadSchedPolicy(n int) error

Sets the scheduling policy for default context’s thread pool.

This option requires ZeroMQ version 4.1, and is not available on Windows.

Supported values for this option can be found in sched.h file, or at http://man7.org/linux/man-pages/man2/sched_setscheduler.2.html

This option only applies before creating any sockets on the context.

Default value: -1

Returns ErrorNotImplemented41 with ZeroMQ version < 4.1

Returns ErrorNotImplementedWindows on Windows

func Term ¶

func Term() error

Terminates the default context.

For linger behavior, see: http://api.zeromq.org/4-1:zmq-ctx-term

func Version ¶

func Version() (major, minor, patch int)

Report 0MQ library version.

func Z85decode ¶

func Z85decode(s string) string

Decode a binary key from Z85 printable text

See: http://api.zeromq.org/4-1:zmq-z85-decode

func Z85encode ¶

func Z85encode(data string) string

Encode a binary key as Z85 printable text

See: http://api.zeromq.org/4-1:zmq-z85-encode

type Context ¶

A context that is not the default context.

type Context struct {
    // contains filtered or unexported fields
}

func NewContext ¶

func NewContext() (ctx *Context, err error)

Create a new context.

func (*Context) GetBlocky ¶

func (ctx *Context) GetBlocky() (bool, error)

Returns the blocky setting.

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func (*Context) GetIoThreads ¶

func (ctx *Context) GetIoThreads() (int, error)

Returns the size of the 0MQ thread pool.

func (*Context) GetIpv6 ¶

func (ctx *Context) GetIpv6() (bool, error)

Returns the IPv6 option.

func (*Context) GetMaxMsgsz ¶

func (ctx *Context) GetMaxMsgsz() (int, error)

Returns the maximum message size.

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func (*Context) GetMaxSockets ¶

func (ctx *Context) GetMaxSockets() (int, error)

Returns the maximum number of sockets allowed.

func (*Context) GetRetryAfterEINTR ¶

func (ctx *Context) GetRetryAfterEINTR() bool

Returns the retry after EINTR setting.

func (*Context) NewSocket ¶

func (ctx *Context) NewSocket(t Type) (soc *Socket, err error)

Create 0MQ socket in the given context.

WARNING: The Socket is not thread safe. This means that you cannot access the same Socket from different goroutines without using something like a mutex.

For a description of socket types, see: http://api.zeromq.org/4-1:zmq-socket#toc3

func (*Context) SetBlocky ¶

func (ctx *Context) SetBlocky(i bool) error

Sets the blocky behavior.

See: http://api.zeromq.org/4-2:zmq-ctx-set#toc3

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func (*Context) SetIoThreads ¶

func (ctx *Context) SetIoThreads(n int) error

Specifies the size of the 0MQ thread pool to handle I/O operations. If your application is using only the inproc transport for messaging you may set this to zero, otherwise set it to at least one. This option only applies before creating any sockets.

Default value: 1

func (*Context) SetIpv6 ¶

func (ctx *Context) SetIpv6(i bool) error

Sets the IPv6 value for all sockets created in the context from this point onwards. A value of true means IPv6 is enabled, while false means the socket will use only IPv4. When IPv6 is enabled, a socket will connect to, or accept connections from, both IPv4 and IPv6 hosts.

Default value: false

func (*Context) SetMaxMsgsz ¶

func (ctx *Context) SetMaxMsgsz(n int) error

Set maximum message size.

Default value: INT_MAX

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

func (*Context) SetMaxSockets ¶

func (ctx *Context) SetMaxSockets(n int) error

Sets the maximum number of sockets allowed.

Default value: 1024

func (*Context) SetRetryAfterEINTR ¶

func (ctx *Context) SetRetryAfterEINTR(retry bool)

Sets the retry after EINTR setting.

Initital value is true.

func (*Context) SetThreadPriority ¶

func (ctx *Context) SetThreadPriority(n int) error

Sets scheduling priority for internal context’s thread pool.

This option requires ZeroMQ version 4.1, and is not available on Windows.

Supported values for this option depend on chosen scheduling policy. Details can be found in sched.h file, or at http://man7.org/linux/man-pages/man2/sched_setscheduler.2.html

This option only applies before creating any sockets on the context.

Default value: -1

Returns ErrorNotImplemented41 with ZeroMQ version < 4.1

Returns ErrorNotImplementedWindows on Windows

func (*Context) SetThreadSchedPolicy ¶

func (ctx *Context) SetThreadSchedPolicy(n int) error

Sets the scheduling policy for internal context’s thread pool.

This option requires ZeroMQ version 4.1, and is not available on Windows.

Supported values for this option can be found in sched.h file, or at http://man7.org/linux/man-pages/man2/sched_setscheduler.2.html

This option only applies before creating any sockets on the context.

Default value: -1

Returns ErrorNotImplemented41 with ZeroMQ version < 4.1

Returns ErrorNotImplementedWindows on Windows

func (*Context) Term ¶

func (ctx *Context) Term() error

Terminates the context.

For linger behavior, see: http://api.zeromq.org/4-1:zmq-ctx-term

type Errno ¶

An Errno is an unsigned number describing an error condition as returned by a call to ZeroMQ. It implements the error interface. The number is either a standard system error, or an error defined by the C library of ZeroMQ.

type Errno uintptr

func AsErrno ¶

func AsErrno(err error) Errno

Convert error to Errno.

Example usage:

switch AsErrno(err) {

case zmq.Errno(syscall.EINTR):
    // standard system error

    // call was interrupted

case zmq.ETERM:
    // error defined by ZeroMQ

    // context was terminated

}

See also: examples/interrupt.go

func (Errno) Error ¶

func (errno Errno) Error() string

Return Errno as string.

type Event ¶

Used by (*Socket)Monitor() and (*Socket)RecvEvent()

type Event int

func (Event) String ¶

func (e Event) String() string

Socket event as string.

type Flag ¶

Used by (*Socket)Send() and (*Socket)Recv()

type Flag int

func (Flag) String ¶

func (f Flag) String() string

Socket flag as string.

type Mechanism ¶

Specifies the security mechanism, used by (*Socket)GetMechanism()

type Mechanism int

func (Mechanism) String ¶

func (m Mechanism) String() string

Security mechanism as string.

type Polled ¶

Return type for (*Poller)Poll

type Polled struct {
    Socket *Socket // socket with matched event(s)
    Events State   // actual matched event(s)
}

type Poller ¶

type Poller struct {
    // contains filtered or unexported fields
}

func NewPoller ¶

func NewPoller() *Poller

Create a new Poller

func (*Poller) Add ¶

func (p *Poller) Add(soc *Socket, events State) int

Add items to the poller

Events is a bitwise OR of zmq.POLLIN and zmq.POLLOUT

Returns the id of the item, which can be used as a handle to (*Poller)Update and as an index into the result of (*Poller)PollAll

func (*Poller) Poll ¶

func (p *Poller) Poll(timeout time.Duration) ([]Polled, error)

Input/output multiplexing

If timeout < 0, wait forever until a matching event is detected

Only sockets with matching socket events are returned in the list.

Example:

poller := zmq.NewPoller()
poller.Add(socket0, zmq.POLLIN)
poller.Add(socket1, zmq.POLLIN)
//  Process messages from both sockets
for {
    sockets, _ := poller.Poll(-1)
    for _, socket := range sockets {
        switch s := socket.Socket; s {
        case socket0:
            msg, _ := s.Recv(0)
            //  Process msg
        case socket1:
            msg, _ := s.Recv(0)
            //  Process msg
        }
    }
}

func (*Poller) PollAll ¶

func (p *Poller) PollAll(timeout time.Duration) ([]Polled, error)

This is like (*Poller)Poll, but it returns a list of all sockets, in the same order as they were added to the poller, not just those sockets that had an event.

For each socket in the list, you have to check the Events field to see if there was actually an event.

When error is not nil, the return list contains no sockets.

func (*Poller) Remove ¶

func (p *Poller) Remove(id int) error

Remove a socket from the poller

Returns ErrorNoSocket if the id was out of range

func (*Poller) RemoveBySocket ¶

func (p *Poller) RemoveBySocket(soc *Socket) error

Remove a socket from the poller

Returns ErrorNoSocket if the socket didn't match

func (*Poller) String ¶

func (p *Poller) String() string

Poller as string.

func (*Poller) Update ¶

func (p *Poller) Update(id int, events State) (previous State, err error)

Update the events mask of a socket in the poller

Replaces the Poller's bitmask for the specified id with the events parameter passed

Returns the previous value, or ErrorNoSocket if the id was out of range

func (*Poller) UpdateBySocket ¶

func (p *Poller) UpdateBySocket(soc *Socket, events State) (previous State, err error)

Update the events mask of a socket in the poller

Replaces the Poller's bitmask for the specified socket with the events parameter passed

Returns the previous value, or ErrorNoSocket if the socket didn't match

type Reactor ¶

type Reactor struct {
    // contains filtered or unexported fields
}

func NewReactor ¶

func NewReactor() *Reactor

Create a reactor to mix the handling of sockets and channels (timers or other channels).

Example:

reactor := zmq.NewReactor()
reactor.AddSocket(socket1, zmq.POLLIN, socket1_handler)
reactor.AddSocket(socket2, zmq.POLLIN, socket2_handler)
reactor.AddChannelTime(time.Tick(time.Second), 1, ticker_handler)
reactor.Run(time.Second)

Warning:

There are problems with the reactor showing up with Go 1.14 (and later) such as data race occurrences and code lock-up. Using SetRetryAfterEINTR seems an effective fix, but at the moment there is no guaranty.

func (*Reactor) AddChannel ¶

func (r *Reactor) AddChannel(ch <-chan interface{}, limit int, handler func(interface{}) error) (id uint64)

Add channel handler to the reactor.

Returns id of added handler, that can be used later to remove it.

If limit is positive, at most this many items will be handled in each run through the main loop, otherwise it will process as many items as possible.

The handler function receives the value received from the channel.

func (*Reactor) AddChannelTime ¶

func (r *Reactor) AddChannelTime(ch <-chan time.Time, limit int, handler func(interface{}) error) (id uint64)

This function wraps AddChannel, using a channel of type time.Time instead of type interface{}.

func (*Reactor) AddSocket ¶

func (r *Reactor) AddSocket(soc *Socket, events State, handler func(State) error)

Add socket handler to the reactor.

You can have only one handler per socket. Adding a second one will remove the first.

The handler receives the socket state as an argument: POLLIN, POLLOUT, or both.

func (*Reactor) RemoveChannel ¶

func (r *Reactor) RemoveChannel(id uint64)

Remove a channel from the reactor.

Closed channels are removed automatically.

func (*Reactor) RemoveSocket ¶

func (r *Reactor) RemoveSocket(soc *Socket)

Remove a socket handler from the reactor.

func (*Reactor) Run ¶

func (r *Reactor) Run(interval time.Duration) (err error)

Run the reactor.

The interval determines the time-out on the polling of sockets. Interval must be positive if there are channels. If there are no channels, you can set interval to -1.

The run alternates between polling/handling sockets (using the interval as timeout), and reading/handling channels. The reading of channels is without time-out: if there is no activity on any channel, the run continues to poll sockets immediately.

The run exits when any handler returns an error, returning that same error.

func (*Reactor) SetVerbose ¶

func (r *Reactor) SetVerbose(verbose bool)

type Socket ¶

Socket functions starting with `Set` or `Get` are used for setting and getting socket options.

type Socket struct {
    // contains filtered or unexported fields
}

func NewSocket ¶

func NewSocket(t Type) (soc *Socket, err error)

Create 0MQ socket in the default context.

WARNING: The Socket is not thread safe. This means that you cannot access the same Socket from different goroutines without using something like a mutex.

For a description of socket types, see: http://api.zeromq.org/4-1:zmq-socket#toc3

func (*Socket) Bind ¶

func (soc *Socket) Bind(endpoint string) error

Accept incoming connections on a socket.

For a description of endpoint, see: http://api.zeromq.org/4-1:zmq-bind#toc2

func (*Socket) ClientAuthCurve ¶

func (client *Socket) ClientAuthCurve(server_public_key, client_public_key, client_secret_key string) error

Set CURVE client role.

func (*Socket) ClientAuthPlain ¶

func (client *Socket) ClientAuthPlain(username, password string) error

Set PLAIN client role.

func (*Socket) Close ¶

func (soc *Socket) Close() error

If not called explicitly, the socket will be closed on garbage collection

func (*Socket) Connect ¶

func (soc *Socket) Connect(endpoint string) error

Create outgoing connection from socket.

For a description of endpoint, see: http://api.zeromq.org/4-1:zmq-connect#toc2

func (*Socket) Context ¶

func (soc *Socket) Context() (*Context, error)

Return the context associated with a socket

func (*Socket) Disconnect ¶

func (soc *Socket) Disconnect(endpoint string) error

Disconnect a socket.

For a description of endpoint, see: http://api.zeromq.org/4-1:zmq-disconnect#toc2

func (*Socket) GetAffinity ¶

func (soc *Socket) GetAffinity() (uint64, error)

ZMQ_AFFINITY: Retrieve I/O thread affinity

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc3

func (*Socket) GetBacklog ¶

func (soc *Socket) GetBacklog() (int, error)

ZMQ_BACKLOG: Retrieve maximum length of the queue of outstanding connections

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc4

func (*Socket) GetConnectTimeout ¶

func (soc *Socket) GetConnectTimeout() (time.Duration, error)

ZMQ_CONNECT_TIMEOUT: Retrieve connect() timeout

Returns ErrorNotImplemented42 with ZeroMQ version < 4.2

See: http://api.zeromq.org/4-2:zmq-getsockopt#toc5

func (*Socket) GetCurvePublickeyRaw ¶

func (soc *Socket) GetCurvePublickeyRaw() (string, error)

ZMQ_CURVE_PUBLICKEY: Retrieve current CURVE public key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc5

func (*Socket) GetCurvePublickeykeyZ85 ¶

func (soc *Socket) GetCurvePublickeykeyZ85() (string, error)

ZMQ_CURVE_PUBLICKEY: Retrieve current CURVE public key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc5

func (*Socket) GetCurveSecretkeyRaw ¶

func (soc *Socket) GetCurveSecretkeyRaw() (string, error)

ZMQ_CURVE_SECRETKEY: Retrieve current CURVE secret key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc6

func (*Socket) GetCurveSecretkeyZ85 ¶

func (soc *Socket) GetCurveSecretkeyZ85() (string, error)

ZMQ_CURVE_SECRETKEY: Retrieve current CURVE secret key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc6

func (*Socket) GetCurveServerkeyRaw ¶

func (soc *Socket) GetCurveServerkeyRaw() (string, error)

ZMQ_CURVE_SERVERKEY: Retrieve current CURVE server key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc7

func (*Socket) GetCurveServerkeyZ85 ¶

func (soc *Socket) GetCurveServerkeyZ85() (string, error)

ZMQ_CURVE_SERVERKEY: Retrieve current CURVE server key

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc7

func (*Socket) GetEvents ¶

func (soc *Socket) GetEvents() (State, error)

ZMQ_EVENTS: Retrieve socket event state

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc8

func (*Socket) GetFd ¶

func (soc *Socket) GetFd() (int, error)

ZMQ_FD: Retrieve file descriptor associated with the socket

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc9

func (*Socket) GetGssapiPlaintext ¶

func (soc *Socket) GetGssapiPlaintext() (bool, error)

ZMQ_GSSAPI_PLAINTEXT: Retrieve GSSAPI plaintext or encrypted status

Returns ErrorNotImplemented41 with ZeroMQ version < 4.1

See: http://api.zeromq.org/4-1:zmq-getsockopt#toc10

func (*Socket) GetGssapiPrincipal ¶